Threads for RiderOfGiraffes

  1. 3

    The site displays poorly on mobile, so I had to turn on the reader view. Is the output of the commands shown? If yes, I couldn’t see it. So, what is the difference? :) I assume that shift n would bail out early with error, if n is greater than the number of arguments?

    1. 2

      No, the output of the final commands is not shown, because I know from feedback that for many of my readers they prefer to go and experiment for themselves.

      In short, suppose you have only two parameters. Then “shift ; shift ; shift” ends up with all parameters unset, but “shift 3” leaves the parameters unchanged.

      Yes, I know it renders poorly on mobile. Indeed, it just renders poorly, period. I’d like to get the time and knowledge to change it, but the existing system is … (significant pause) … complicated, and changing it would be … (significant pause) … difficult. You can read more about how it works here:

      https://www.solipsys.co.uk/new/HowTheFarragoWorks.html?UA31LO

      Every time I’ve approached someone to get assistance in upgrading and updating the site, they’ve taken a look and said “Nope, not possible, you’ll just have to replace everything.” Which isn’t really an option.

    1. 2

      I would like to propose a new tag: Algorithms

      When suggesting new tags it is good practice to list a bunch of lobste.rs submissions that would deserve the tag. I haven’t seen many articles that are purely about algorithms so I’m not sure I support the creation of an “Algorithm” tag.

      Failing that, can someone suggest the correct tag to use if one submits an algorithm?

      When no tag applies to the story you’re submitting you can use the “programming” one.

      1. 3

        There have been several occasions where I’ve come across algorithms and come here to submit them, then not done so because they’re not about programming, they’re about algorithms, and no other existing tag really fits.

        So perhaps there’re aren’t many existing submissions that would use the tag because the tag is absent, and people thereby don’t submit things that would use it.

        Then again, maybe an article that’s about an algorithm without being about programming doesn’t really fit the direction of this site, but that’s why I’ve asked the question.

        1. 7

          I personally would like to see algorithm posts, so I do recommend posting them, under compsci tag. After a while we could check how they are received.

          1. 3

            There have been several occasions where I’ve come across algorithms and come here to submit them, then not done so because they’re not about programming, they’re about algorithms, and no other existing tag really fits.

            I suspect that compsci or programming or math could all work.

            1. 3

              Could you list some of the articles you wanted to submit but didn’t?

              1. 1

                It’s been too long, I don’t have any in mind now, and can’t remember those that I passed over. I know that Lobsters is more focussed and usually don’t consider posting things here because my interests are, in general, not strongly aligned, so when I’ve been reading, Lobsters has usually not come to mind.

                I know there have been some, but I can’t say what they were. After this discussion I’ll pay more attention.

                1. 1

                  When in doubt, just post it with the best fitting tag, or programming if you’re not sure. Few will mind if you use a “wrong” tag if it’s an interesting article and the suggest mechanism can correct this.

          1. 20

            The compsci tag probably covers this, I think?

            1. 0

              I don’t really see “CompSci” as covering an article about the polynomial time algorithm for identifying whether a number is prime, but maybe that view is coloured by being a PhD in math who has ended up doing a lot of computing.

              1. 13

                If that isn’t computer science, I don’t know what is. Granted, that’s closer to maths than most of it, but it’s still stereotypically computer science.

                1. 3

                  That sounds very much like computer science to me.

                  1. 3

                    IMHO as soon as you’re determining the time or space an algorithm requires, you’re in the realm of CompSci. After all, those metrics only work in a framework where you compute :-)

                    (but that may be my German-colored view of CompSci, which is rooted in math and depending on the department, in math only, unlike other regions where CompSci has a closer relationship to electrical engineering)

                1. 2

                  Close to the start it says:

                  White can open the game in any of twenty different ways, and black can respond with twenty of its own moves, creating 4,000 possible sequences after the first full turn.

                  By my reckoning 20 times 20 is 400, not 4000.

                  1. 2

                    Thank you! You are correct. I’m surprised I didn’t spot this. I checked Silver’s book and that section is reprinted there too.

                    I’ve fixed this and the new version is being deployed.

                  1. 3

                    disclaimer: I’ve only watched the video but haven’t read any of the presenter’s work.

                    this idea of setting up “circuits” in graph coloring problems is neat, but I’m curious what the research angle is. 4-coloring planar graphs is polynomial time on classical computers [1], so if we encode any of these NP-complete problems into a coloring circuit, the circuit itself must be exponential in the size of the problem. otherwise, we’d have a polynomial time solution.

                    so, improving algorithms for coloring graphs won’t lead to a breakthrough, since the input size is already exponential. perhaps there’s some way of encoding graph coloring as a physical process?

                    [1] https://en.wikipedia.org/wiki/Four_color_theorem#Simplification_and_verification

                    1. 3

                      The circuits that you create need not be planar, that’s why we make the change from colouring maps to colouring networks. That’s mentioned early in the video where we have the complete network on five nodes.

                      So you are mistaken, the network size is only polynomial in the size of the instance of the problem, and a breakthrough in colouring would be important.

                      1. 2

                        ah, it’s not clear to me from the video that it’s necessary to go beyond planar graphs for completeness. the two examples given, AND and adder gates, are both planar. but perhaps NAND gates cannot be made into a planar circuit? or maybe there’s an issue with “circuit layout,” where even though each gate is planar, encoding an arbitrary boolean circuit requires sacrificing planarity?

                        if planar graphs suffice, then my point still holds, where this construction would imply a polynomial time algorithm for NP problems. but if not, it’d be cool to see a “lower bound” result that shows how planarity doesn’t end up working out.

                        1. 2

                          The relevant observation here is that the inputs for the adder (say) are in the interior of the network, so getting “signals” into them requires crossing lines.

                          There are results about trying to create planar equivalents, and they do (in some circumstances) grow exponentially.

                    1. 3

                      What is the solution of exactly 2 cycles and size 5?

                      A square with one diagonal has two cycles of length three, and one cycle of length four, giving 3 cycles in total.

                      A bow tie with 5 vertices also has 3 cycles.

                      1. 5

                        A cycle in a graph is usually defined to not have any duplicated vertices (apart from ending where it started), in which case a bow tie has only two cycles.

                        1. 3

                          Thanks

                        2. 3

                          I’ve added a note near the top now to clarify that “cycles” don’t have repeated vertices.

                          Thanks for the comment/question, I think the post is better for the change I made as a result.

                        1. 1

                          This whole issue gives me tummy aches… I live this stuff and so many get it wrong.

                          • Failing hard is better than failing flakily. ie. If the only fix is a software upgrade, you want to know soon as possible, as deterministically as possible so you can find root cause and fix as soon as possible. ie. Continuing to sort of work sort of not work in an undefined manner is not degrading gracefully and is not a good thing.
                          • If the value of the entire system was hard dependent on the stock reordering thing working, halting to maintain the consistency of the stock accounting would be The Right Thing. But it wasn’t. “Re-ordering was not automatic, but staff would be alerted when stock was low on any items and decisions could be made. “ ie. The value of the system was it operating as a till. In selling things. If they ran out of stock… because they sold it all, that actually would be “A Good Thing”. Having stock but being unable to sell it… not so good. Not running out of stock and selling as fast as possible would be better. ie. I would have designed as “Best Effort”. Maintain stock info if I could, drop info and continue selling if I couldn’t.
                          • A better solution would be push instead of poll. No doubt some tills would be quiet. They should have a high tide mark and start pushing their data to the server when it hits it… and then drop info if the server is still to slow. (The server could still poll when it was quiescent.)
                          • Dropping info is OK, just log that you are doing so.

                          In a previous life a CEO told me a war story of a multi user real time system that had complaints that it was “slow in the morning”.

                          Investigation show it performed to spec, but was slower than at other times, but human typists occasionally screwed up because they were used to normal response times.

                          Solution: A tiny “sleep” between characters…. enough to make the response time consistent across the day and let the cpu catch up during the busy period. Result: Happy humans.

                          1. 1

                            This is a long reply because I wanted to address all your points.

                            This whole issue gives me tummy aches…

                            Sorry.

                            I live this stuff and so many get it wrong.

                            I agree that many get it wrong, which is one reason, I think, why stories like this should be shared more widely and become part of the culture, including - perhaps especially - when people have got things wrong.

                            Failing hard is better than failing flakily.

                            Not always. Yes, if you have control over the software, and if total loss of service is acceptable, then failing hard is the fastest way to find problems and have the chance to fix them. I often work in situations where non-service is unacceptable, and we’re working with unstable software. In those cases failing hard isn’t an option, and definitely is not “better”.

                            What’s needed in all cases is full and proper analysis, followed in the fullness of time by a full and proper post-mortem, with some way of integrating the lessons learned into future development processes.

                            If the value of the entire system was hard dependent on the stock reordering thing working, halting to maintain the consistency of the stock accounting would be The Right Thing. But it wasn’t.

                            “Hard dependent” isn’t the only criterion. In this case there was a balance of concerns, and one’s own objective function as a software developer might not be the same as that of one’s customer.

                            “Re-ordering was not automatic, but staff would be alerted when stock was low on any items and decisions could be made.” ie. The value of the system was it operating as a till. In selling things.

                            Not the only value. In general operation the system worked perfectly, and the flags for ordering stock were an important part of their operation. The only problem was when demand exceeded capacity. Since capacity couldn’t be increased, demand had to be decreased. There was no option.

                            So demand could be increased by abandoning the stock logging. That was deemed less acceptable than slowing own the ringing up of sales by a few percent.

                            If they ran out of stock… because they sold it all, that actually would be “A Good Thing”.

                            That’s not the case for every vendor. For some vendors, part of their reputation is not being out of stock. Yes, for some vendors running out of stock isn’t a problem … that’s not universally true. Sales and marketing interacts with psychology, and people are weird. I’ve seen many times that apparently water-tight analyses by programmers turn out to be less good than those done by others with more “soft” skills.

                            “No plan survives contact with the enemy” – Field Marshal Helmuth Karl Bernhard Graf von Moltke

                            Having stock but being unable to sell it… not so good.

                            Before the “graceful degradation” change that was a problem … they had stock and couldn’t sell it. After the change they could sell the stock, albeit at a slightly reduced rate … one that was deemed acceptable by the vendor.

                            Not running out of stock and selling as fast as possible would be better.

                            Yes.

                            I would have designed as “Best Effort”. Maintain stock info if I could, drop info and continue selling if I couldn’t.

                            That was presented as an option, it was discussed, all the ramifications considered, and it was rejected.

                            A better solution would be push instead of poll.

                            Possibly, but not viable given the hardware.

                            Dropping info is OK, just log that you are doing so.

                            Again, not universally true.

                            1. 1

                              Failing hard is better than failing flakily.

                              Not always. Yes, if you have control over the software, and if total loss of service is acceptable, then failing hard is the fastest way to find problems and have the chance to fix them. I often work in situations where non-service is unacceptable, and we’re working with unstable software

                              The problem is Nasal Daemons.

                              This is asm code (C code suffers from this a lot, all languages to some degree).

                              So what would happen if instead of checking for the storage bound and halting… it just didn’t check and kept on storing?

                              For some undefined amount of time, it might continue working.

                              For some undefined amount of time it might start behaving more and more crazily. Including sending crazy results to the server with undefined consequences of doing that.

                              Possibly months of corrupted and unrecoverable data.(Yes, I have seen that happen).

                              At some undefined point in time it would STILL cease working.

                              As they put it in the C world… venture into “undefined” behaviour, the compiler is entitled to make daemons fly out of your nose….

                              And all this would depend on exact version of firmware, hardware, device usage history, system load, phase of moon, server state, server version….. A complete and horrible nightmare to debug, and recover from.

                              No. No. NO! Failing HARD IS the right thing to do rather than venture into undefined and undefinable behaviour.

                              Of course, handling sensibly is better than failing hard, but failing hard is better than going flaky and unreliable and undefined.

                              You can’t argue, “The customer prefers it to stopping working”, as you can’t tell the customer what the consequences are as you cannot know them your self!

                              If you could, that would be defined behaviour!

                              1. 1

                                Hah! We’re arguing past each other.

                                You’re talking about bugs, and I’m talking about choosing between types of behaviour under limiting circumstances.

                                The situation here wasn’t a bug, it was a question of how to behave when certain circumstances arose.

                                1. 1

                                  Ok. Agreed.

                                  The normal way in the world is when the programmer cods that limit, he asks so what should we do if we hit that limit?

                                  I bet his marketing folk, said, Nah, probably won’t happen, handling that’s a version 2 feature, we’ll discuss it with the customer when and if it arises.

                                  And that’s what you get.

                                  The programmer did the Right Thing, he made the till stop working instead of going undefined.

                                  Graceful degradation in the real world is a V2 (or v10) feature.

                                  1. 1

                                    Yes.

                                    V1: if you hit the limit, stop the tills so we know it’s happening. (It probably won’t)

                                    Ah. It does. OK, then …

                                    V2: Stopping the tills is unacceptable, and it’s happening. So instead, when they hit a lower tide mark, start slowing the tills down.

                                    So V2 is degraded, but gracefully, rather than catastrophically, and that was the point of the original post.

                          1. 10

                            This has been discussed before, but I was wondering if anything has changed.

                            Several difficulties and problems were raised … have they been addressed?

                            Does anyone use it?

                            1. 11

                              I’ve been there for close to 2 years, and have tried to build my own SSB server from scratch (in a non-JS language). Feel free to ask any questions. For starters:

                              • The low level protocol (transport encryption, RPC and discovery) is very well documented.

                              • The application level protocol has almost no documentation, and what’s there is outdated. You really have to resort to reverse engineer behaviour from existing applications, or reading other’s code.

                              • Replication/gossip mechanism is very inefficient, which leads to clients (especially mobile ones) spending a lot of time during the initial sync. There’s a newer gossip protocol which fixes some of these problems, but has zero documentation, and there’s only one implementation (in JS). There are no plans to port it to other languages since there’s a lot of tricky edge cases in there.

                              • Yes, the JSON encoding was a mistake. There’s a new format using CBOR, but it’s still a few ways off in terms of mainstream usage in the network.

                              • There are questionable decisions at the application level. For example, anyone can assign you new profile pictures or visible names, which can–and has–lead to bullying/name-calling.

                              In terms of community, it’s mostly tech-centric, most discussions are either about SSB itself, or related protocols. The overall spirit is positive, focusing on sustainable living, gardening, off-grid, etc.

                              However, the community is very small. This can get tiring, considering that most clients will show any replies to threads you follow at the top of your timeline (you will see the same 3 to 5 people all the time).

                              1. 4

                                I’ve also built a partial SSB implementation, in C++. I found a C port of the CLI tool (in an obscure Git repo hosted in SSB), which helped immeasurably with the secure handshake and packet codec. I used Couchbase Lite [of which I’m the architect] as the database. This proved a lot faster than the JS data store, but I still found that pulling all the subscribed content from one pub (on which I’m following a handful of accounts) resulted in a 600MB database. It would have helped if the protocol had an option to pull only messages back to a certain date.

                                I’d love to know more about the new protocol, but not if the only way is to decipher a JS codebase.

                                It’s a shame they’re so JS-centric. That’s a serious problem for iOS, which has security restrictions that disallow JITs outside of a web browser. Not to mention embedded systems. (And on a personal level I dislike doing serious programming in JS; it feels like sculpting in Jell-O.)

                                1. 3

                                  There are two C implementations of the low level protocol: one for the secret handshake and one for the boxstream (transport encryption). There’s also some integration tests that you can run against your implementation to validate that everything works.

                                  As for the new replication protocol: the new CBOR format includes “off-chain” contents, which means that the actual log only contains a hash of the post content. This should make initial sync much faster, since clients only fetch the chain of hashes, without downloading anything else.

                                  Messages can also be downloaded out of order, so you only download what you want, if you have the hash for it. As most things, though, the only implementation is in JS.

                                  As for the database, I planned to use SQLite, but never got far enough to test that. I’m unconvinced that the log is a good abstraction for the kind of apps that SSB is used right now (social media). There are future plans to plug more applications on top of the log replication, but that’s in the long term, while the current use-cases are suffering from it.

                                  Edit: wanted to say, though, that for me the biggest block when developing an SSB implementation is the lack of documentation w.r.t. the application-level protocol, and forcing you to develop everything on top of the log abstraction. The JSON formatting can be painful, but solved via forking some json library and doing some changes (hacky, but it works).

                                2. 1

                                  Yes, the JSON encoding was a mistake.

                                  Was JSON not fast enough?

                                  1. 4

                                    It’s not about JSON per-se, but more about how message signing works. In SSB, every post is represented as a JSON blob signed with your publick key, and it expects other clients to validate this, as well as produce valid JSON messages.

                                    The spec goes over the requirements of a valid message, as well as the steps to compute a valid signature. Unfortunately, it assumes things like key order (which the official JSON spec doesn’t say anything about), indentiation, spacing, etc. (This all goes back to how the V8 engine implements JSON.stringify()). This adds a lot of complexity when implementing SSB in another language, as most JSON libraries won’t care about specific formatting when printing, and specifically the key order requirement makes it quite complicated.

                                    All in all, it’s not the end of the world, but it adds enough friction to make SSB pretty dependend on the “blessed” javascript implementation.

                                3. 5

                                  I use it regularly. Why..? After being a heavy social media user on the usual platforms, I’ve pretty much removed myself and don’t participate, but Scuttlebutt is the exception because it’s a fun place to be. Nothing more, nothing less.

                                  1. 3

                                    What difficulties and problems were raised?

                                    1. 12

                                      There’s two big obstacles I’ve seen that seem specific to Scuttlebutt:

                                      • There’s no easy way to share identities across devices. If you want to use Scuttlebutt on your computer and your phone, they’ll be separate accounts.

                                      • The protocol is built around an append-only log, which I’m not convinced is a good principle for any social network. Inadvertent mistakes are forever (eg. I post an unboxing photo that has my unredacted invoice visible; I paste an embarrassing link by accident).

                                        It also seems like you could grief pub servers (the Scuttlebutt “hub nodes” that federate content more widely). What happens if someone posts a bunch of illegal content to the pub? As I understand it, all the pub users will pull that content down. You might be able to blacklist certain posts in your client, and you can block users, but their content is still on your device. (Bitcoin has faced similar problems.)

                                      1. 2

                                        Your objection to log storage is valid, but there are ways around it. The data format could have ways to redact posts out of the log while leaving the overall integrity intact; in fact all revisions of a post other than the latest one could be redacted.

                                        Of course the redactions need to be propagated, and there’s no guarantee every copy will be redacted, but that’s an intrinsic problem with most P2P protocols, since distributed caching/replication is so important for availability.

                                        1. 1

                                          Good points.

                                          Also ironically where Facebook could have a chance to differentiate themselves, but chose to go in almost the exact different direction:

                                          • “with federated networking you are trusting each and every host that your host ever federated with to delete a post, with us, once you click delete it is gone. Worldwide. Same with sharing: if you share something with your close friends it stays there. With a federated network it depends on every host around the globe sticking implementing the rules correctly and sticking to the rules.”

                                          • fortunately IMO Facebook messed up massively early on and now everyone in tech now they are fundamentally untrustworthy.

                                        2. 8

                                          The main problem I saw when I looked into it was that it was a single program rather than a well-defined protocol that anyone in the ecosystem could implement.

                                          This might have changed by now, but (for instance) there were aspects baked into the protocol that fundamentally prevented you from building a compatible client unless you used a JSON serializer with the exact same behavior as node.js, because the cryptographic identity of a post was based on a checksum of the output of that particular serializer rather than some inherent property of the post. An easy mistake to make, but one with far-reaching consequences.

                                          1. 6

                                            That’s my issue as well. It relies heavily on the interaction of a few dozen NodeJS repos. Different frontends all rely on the same backend code, making it not-that-diverse.

                                            Also, while the protocol itself is well documented and designed, there are some obvious shortcomings. The protocol relies on hashes of pretty-printed JSON. The last time I checked for documentation on HOW to pretty-print that json, it was documented as “like v8 does it”. Tell you - it’s REALLY hard to format JSON like V8 JSON.format(x, true) does. Especially floating point numbers.

                                            Now this could easily be fixed by changing the protocol from hash-of-pretty-printed-json-subobject to hash-of-blob. ({"data": "{\"foo\" 42}", "hash": ...} vs. {"data": {"foo": 42}, hash: ...} But you can’t do that without breaking compatibility. Worse, relying on hash-chains, you need to implement the old behaviour to be able to verify old hash chains.

                                            1. 5

                                              That’s my top issue too. Which is sad, because there’s so much prior art on canonicalizing JSON, going back to 2010 or so.

                                              The spec is fine, but limited. It doesn’t cover all of the interactions between peers; there are plenty of messages, and properties in the schema, that aren’t documented.

                                              A lot of the discussion and information about the protocol takes place on Scuttlebutt itself, meaning it’s (AFAICT) invisible to search engines, and accessible over HTTP only through some flaky gateways that often time out.

                                              The main client is (like everything else) written in JS, so it’s a big Electron app, and in my experience very slow and resource hungry. I only joined two pubs and followed a handful of people and topics, but every time I fire up the app, it starts a frenzy of downloading and database indexing that lasts a long time. (They use a custom log-based DB engine written in JS.)

                                              Part of the slowness must be because when you join a pub you’re implicitly following every user of that pub, and I believe all of the IDs they’re following. So there’s kind of an explosion of data that it pulls in indiscriminately to replicate the social graph and content.

                                            2. 4

                                              Reading the previous discussions shows a degree of frustration and scepticism. I’m sure it’s changed, and many of the questions will have been addressed, but the previous discussions are unconvincing.

                                              Here are some links to some of them … it’s worth reading them in context:

                                              https://lobste.rs/s/rgce6h/manyverse_mobile_scuttlebutt_client

                                              https://lobste.rs/s/hncoad/secure_scuttlebutt

                                              https://lobste.rs/s/l9vqm4/scuttlebutt_protocol_guide

                                              https://lobste.rs/s/xe2z2r/scuttlebutt_off_grid_social_network

                                            3. 2

                                              I’m one of the core developers. Happy to answer any questions.

                                              1. 1

                                                Despite the fact it’s in a ‘junkyard’, I believe this issue remains unresolved, which I believe effectively means that:

                                                1. scuttlebutt is not cross platform and only works on x86
                                                2. It’s difficult to implement scuttlebutt libraries and clients in other languages

                                                Limiting development to people who like nodejs, and limiting usage to x86 devices (when it seems like the sort of concept that should work well with mobile devices) massively reduces its appeal.

                                                I would be happy to find that I’m wrong.

                                                1. 3

                                                  You’re off on this one. I’m running SSB on ARM64 just fine, also many pubs are actually just raspberry pis on some closet.

                                                  I is still difficult to implement SSB in other languages mostly because of the amount of work than technical challenges. The mistakes of the past are well understood at this point even if not fixed. At the moment there are 2 Rust based implementations and one based in Go. IIRC there is also implementations in Elixir and Haskell but I am not sure how far they are. I’ve toyed with a client mixing C and Lua (just a toy prototype but it worked).

                                                  1. 2

                                                    It definitely didn’t work on arm last time I tried, so it’s good to hear they’re making some progress. It was the prototype Haskell implementation which pointed to that issue as a blocker: it looks like it hasn’t been updated since, so probably doesn’t work.

                                                    1. 2

                                                      I know it is not what you’re looking for but the JS implementation works fine under Linux/ARM64, which is also how the mobile apps are running.

                                                      My daily driver is a Surface Pro X with an ARM64 CPU. I’ve run go-ssb as native ARM32 binary and the Electron based client apps under win32 x86-32 bits emulation. The reason for it is just that for the love of all that is sacred I can’t find out how to build the native nodejs modules as ARM64 binaries.

                                                    2. 1

                                                      Could you link to the Haskell implementation? I’d be interested in working on that!

                                                1. 13

                                                  I read it but there is something I am still missing.

                                                  So say I have 10,000 notes. I write a new one. How on earth could I link it with others that I’ve forgotten about? Surely I cannot re-read all of 10,000 to see which ones I should link together. I do not get this part of it.

                                                  1. 11

                                                    Incidently, I just stumbled upon this Zettelkasten-like note: Notes should surprise you:

                                                    If reading and writing notes doesn’t lead to surprises, what’s the point?

                                                    If we just wanted to remember things, we have spaced repetition for that. If we just wanted to understand a particular idea thoroughly in some local context, we wouldn’t bother maintaining a system of notes over time.

                                                    This is why we have dense networks of links (Evergreen notes should be densely linked): so that searches help us see unexpected connections.

                                                    This is why we take Evergreen notes should be concept-oriented: so that when writing about an idea that seems new, we stumble onto what we’ve already written about it (perhaps unexpectedly).

                                                    The linked note inside starts with this:

                                                    It’s best to factor Evergreen notes by concept (rather than by author, book, event, project, topic, etc). This way, you discover connections across books and domains as you update and link to the note over time (Evergreen notes should be densely linked).

                                                    So one aspect of the answer suggested here: By writing notes about general concepts, you provoke revisiting them. Through heavy linking you now create connections between related ideas. Through further maintenance like overview notes transitive connections become more direct connections and thus closer. (As a self-refential example: This reminds me of union-find and how it merges disjoint sets).

                                                    1. 5

                                                      How does one find “related notes”?

                                                      I believe the answer lies here:

                                                      Luhmann described his Zettelkasten in different ways. Sometimes he called it a conversation partner and sometimes he described it as a second memory, cybernetic system, a ruminant, or septic tank.

                                                      You actually just keep a big chunk of the notes in your memory. You don’t memorize their literal content, but you know of their existence, so you know approximately where to look. I would say that the Zettelkasten was a tool to enhance his own memory rather than a tool to do the remembering for him.

                                                      The secret to keeping the existence of the largest part of 90.000 notes in memory is probably revisiting them regularly, by following links and browsing at random, both of which the Zettelkasten invites you to do. Luhmann’s notes were all centered around his single general focus area: philosophy and social science, so he was thinking about the full body of work all the time.

                                                      I think the brain is better at this sort of thing than we generally acknowledge. I actually believe that this may be an argument for using an analogue Zettelkasten. You come up with an idea and your brain hints that you have thought about something related before, you just don’t know when and what exactly. You might vaguely remember a particularity of a card though, maybe a tear, a stain or even the smell. So you go browsing, and soon enough you run into a connected idea, which leads you to the subweb of existing ideas that are relevant to the new idea. This rummaging around has the additional benefit of refreshing your memory of existing notes.

                                                      The efficiency on such a large scale is probably for a large part determined by your ability to leverage the hints your unconsciousness gives you, which I think is why Luhmann describes his Zettelkasten in varying, not very rational or strict ways, in an effort to capture this unconscious process.

                                                      1. 4

                                                        My interpretation is that you would have meta-notes that serve as an index for notes about a given topic. (I do that and it’s very useful) So you might not remember the existing 10,000 notes, but surely you can relate your new note to some topics you already touched, and then you can go look at the index for those, and follow the links that look relevant.

                                                        Then, I guess one assumption is that, while exploring the existing web of notes to connect it to your new note, one should dedicate a bit of time and make some new connections if they feel relevant, i.e. do some general “maintenance” of the system.

                                                        1. 2

                                                          If you completely forgot about something, then you have no trigger to even look for something to link to. However, if you have a vague memory of something, a system of indices can be helpful to refresh your memories.

                                                        2. 3

                                                          It’s about destruction and creation. You deconstruct something to use it’s parts for creating something new.

                                                          1. 2

                                                            This is exactly the question none of my reading has answered. I haven’t read “Taking Notes the Smart Way”, but I’ve otherwise read a lot, and nothing seems to address that question.

                                                            I have my own ideas, but I’d love to see how other people solve this.

                                                            1. 7

                                                              Yeah I’m starting to think that “do X the smart way” is mostly BS for most values of X.

                                                              The more I go on the more it seems to me that the system is not important as long as you’re consistent with its use (whether it’s note taking or organising or anything else).

                                                              Also, the most productive people I’ve seen… They don’t use fancy things that make them “super productive”. They just sit down and do the work, and they got good and fast at it by means of practice.

                                                              The more I go on with life the stronger I feel the smell of BS.

                                                              1. 4

                                                                I gave it some thought and this is what I have:

                                                                Linking problem is not solved. If it was solved there would not be any need for adding links in the first place. Why add links at all if you can easily find other notes related to the current one? So the fact that links exist leads me to the conclusion that linking is the actual hard part of this method.

                                                                Second - the whole approach is a hyperlink data base structure before data bases became a thing. This system can be implemented in a single table having 3 columns: 1) ID, 2) Note, 3) References. We have software now so maintaining a data-base in a furniture is probably obsolete.

                                                                But most importantly, like the article said, Zettelkasten  becomes better the more notes are added to it. OK. So the logical conclusion is to invite other people to add their notes to it. Then it grows faster. Everyone is adding their ideas, and creating links between ideas. To me it seems such a state is the ultimate goal of this system. But we have this now, it’s called the internet.

                                                                So I think whatever made that one german scholar so productive probably wasn’t the system itself.

                                                                1. 1

                                                                  You say that as if the internet isn’t a hugely transformative, productivity increasing tool.

                                                                  1. 1

                                                                    I would go as far as to say that for many people it’s the opposite. It can be used as productivity increasing tool and an amazing one at that. But many people use it for other things completely.

                                                                2. 1

                                                                  I think the theory is that if you’re taking a note, you’ve probably already got a bunch of notes about the thing you’re researching handy, so you link to those. For my part that doesn’t match how I generally take notes (I often find myself making note of something I stumble on, and writing summaries/self-tutorials of stuff I’m studying to ‘learn it’ more thoroughly).

                                                                  That said, the Zettelkasten core idea seems to me to be ‘smaller notes, more often’, and also to follow the old adage: “Graphs are a set of Edges that incidentally have some Vertices attached.” Links and granularity are the key takeaways, and there are good ways to do that that aren’t exactly Zettelkasten.

                                                                  1. 1

                                                                    I’m currently trying TiddlyWiki because its UI encourages smaller notes.

                                                                    With a physical Zettelkasten you implicit see neighbor slips as you search a linked one. This is lost in a digital version where searching is delegated to computer and effectively instant. It would be easy to track all kind of implicit connections (backlinks, created before and after) but how to present that in a helpful way?

                                                                3. 2

                                                                  I don’t think the system is supposed to answer that question. Connecting ideas is the job of the human, not the system. However, if you do connect some ideas, you don’t have to remember that connection. Your web of thinking is externalized.

                                                                  I’m sure there are strategies. Randomly showing any two cards seems as good as any strategy. This would only increase the probability (marginally) that two ideas get connected. It would still be up to you to figure out how they are connected.

                                                                  1. 4

                                                                    But to create the connection you have to know that the connection is possible, so you have to be aware of the other cards to which you can connect this one. That’s the essence of what a zettelkasten is supposed to be, and what no one is explaining.

                                                                    Here, I’ve read something, I’ve written a short, pithy note. Where do I file it? To what other cards is it connected? How do I find them?

                                                                    I have some ideas, but it’s supposed to be a solved problem via this method, and I’m seeing zero discussion of it in any of my reading.

                                                                    There’s the puzzle.

                                                                    1. 4

                                                                      I think of zettelkasten a bit differently. In database terminology, I see it as normal form applied to ideas. Ideas are often tightly coupled to their original context. This is why it’s natural to apply a hierarchical structure to notes. You just place the note under a folder which represents the original context. In zettelkasten you make the idea atomic and if you want to give it context then you have to reify that context with a link (a foreign key). Zettelkasten isn’t your schema, zettelkasten is relational algebra. You’re free to come up with any schema you want.

                                                                      Where do I file it?

                                                                      In the same folder with everything else. It’s flat. The structure is provided by the links.

                                                                      How do I find them?

                                                                      I use org-roam in emacs. A digital system helps with search. The original zettelkasten had physical organization by topic and you could traverse the links from there. I’ve only been doing this for a few weeks so maybe search might not scale.

                                                                      Btw, I think your questions are great ones. All I’m saying is I don’t think the system has an answer.

                                                                      1. 2

                                                                        Thanks for the reply … I pick up on this:

                                                                        How do I find them?

                                                                        I use org-roam in emacs. A digital system helps with search.

                                                                        I agree that search solves/avoids a lot of the problems that a purely analog system would/did have.

                                                                        But the whole point of a zettelkasten is that it helps with the search, either to avoid it, or to guide it, or to augment it. Luhmann described “having a conversation” with his zettelkasten.

                                                                        So I’m here, I have a new “card” … I can search the existing ZK for cards that have the same words, but that suffers the problem of combinatorial explosion, and it’s not using the zettelkasten in any kind of clever way.

                                                                        I think there are answers to be found, and perhaps Luhmann had some, and even his enthusiasts don’t really “get it” beyond having a huge box of index cards with some sort of indexing system. It feels from my reading that Luhmann had more than that. Otherwise it’s just a wiki with search.

                                                                        As you may be able to tell, I’ve thought about this a lot.

                                                                        1. 1

                                                                          I think the idea is to never make a note without linking to it from some context of an existing note. So you might have a note on when is the best time to do exercise. That note should be referenced from an index card on exercise, or maybe a note on daily routines.

                                                                          I think there is some hope it’ll be like a wiki, but maybe something more like tvtropes or c2 than Wikipedia where all the ideas are enmeshed are easy to move between.

                                                                      2. 3

                                                                        You connect nodes you know of. Since nodes are connected to nodes, this lets you wander the node links. No node contains every link, because that’s not their job. Their job is to link to whatever you still remember so you can later link it to what you’ve long forgotten.

                                                                        1. 2

                                                                          I have some ideas, but it’s supposed to be a solved problem via this method, and I’m seeing zero discussion of it in any of my reading.

                                                                          How to Take Smart Notes is worth a read, IMO, though it is still kind of nebulous on some points.

                                                                          There’s an “Everything You Need to Do” section. It says:

                                                                          Now add your new permanent notes to the slip-box by:

                                                                          a) Filing each one behind one or more related notes (with a program, you can put one note “behind” multiple notes; if you use pen and paper like Luhmann, you have to decide where it fits best and add manual links to the other notes). Look to which note the new one directly relates or, if it does not relate directly to any other note yet, just file it behind the last one.

                                                                          b) Adding links to related notes

                                                                          c) Making sure you will be able to find this note later by either linking to it from your index or by making a link to it on a note that you use as an entry point to a discussion or topic and is itself linked to the index.

                                                                          Presumably, in order to find things to link if you don’t have them ready to hand, you use the existing index.

                                                                          1. 1

                                                                            The magic seems to lie here:

                                                                            a) Filing each one behind one or more related notes … b) Adding links to related notes

                                                                            This is the question no material or article seems to be answering: How does one find “related notes”? It refers to “the index”, but that’s rarely referred to elsewhere and seems utterly mysterious. How are things indexed?

                                                                            I should write up my musings as best I can to further reveal my confusion and incomprehension. I’ll try to do that.

                                                                            1. 1

                                                                              So, full disclosure, I’ve taken notes on cards before, but at the time I gave them either meaningful names or datestamps rather than Luhmann-style sequential identifiers or what-have-you, so I just kept them in a card box sorted by alpha / date. The collection never grew substantial enough for me to think about other forms of indexing. The cards I’ve held onto are in a single cardboard file box with little alphabet dividers I bought at an office supply store.

                                                                              That said, indexes for paper information storage are a pretty well-established technology.

                                                                              If I were going to take a crack at it for a paper Zettelkasten, I would:

                                                                              • Set up a large card box with alphabet dividers.
                                                                              • When adding a note to my permanent collection:
                                                                                • Search the index for keywords pertaining to the new note
                                                                                • If no card exists in the index for the keyword (name, phrase, concept, etc.) I want to be able to track down again:
                                                                                  • Print the keyword on top of a fresh card
                                                                                • Write down the ID of the related note on any relevant cards (either existing ones or the ones I’ve just created)
                                                                                • File the cards with keywords alphabetically in my index

                                                                              Here’s an abbreviated example from a random page of the index in the first reference volume I could find on my office bookshelf, The Chicago Manual of Style:

                                                                              …
                                                                              ornaments for text break, 1.56 
                                                                              orphans (lines), 2.113, p.899
                                                                              o.s. (old series), 14.132
                                                                              outlines
                                                                                  basic principles, 6.121
                                                                                  parts of a book, 1.4
                                                                                  publishing process, 2.2, fig. 2.1, fig. 2.2
                                                                                  punctuation and format, 6.94, 6.126
                                                                                  See also: lists
                                                                              Oxford comma, 6.18-21. See also commas.
                                                                              …
                                                                              

                                                                              This is a ~900 page reference work with fairly dense text, and about a hundred pages of index, so that ought to give you some very rough idea what ratio is useful for a working reference system, and how far an alphabetized index can scale. The references are mostly to section numbers or figures rather than pages, which seems like a pretty useful parallel to how things could work with numbered cards.

                                                                              The other thing you might want to research is library card catalog approaches. The paper card catalog systems I was taught at length in elementary school have all pretty well been obliterated by electronic databases by now, but there was once a range of well-developed techniques there for indexing into very large collections by author and subject matter.

                                                                              There’s nothing to stop anyone from translating these techniques directly to software, though there are probably more automated ways to get most of the same benefits in any given system. (i.e., tagging systems, automatic keyword indexing, and good old grep.)

                                                                      3. 1

                                                                        I’m thinking of trying this out and my idea was to try some sort of transitive closure view and “show me five random notes” thingymajiggy.

                                                                        1. 1

                                                                          How on earth could I link it with others that I’ve forgotten about? Surely I cannot re-read all of 10,000 to see which ones I should link together. I do not get this part of it.

                                                                          Practically speaking:

                                                                          • in a paper system, the answer is probably an index and a sorted reference collection
                                                                          • in an electronic system, the answer is some combination of search and tagging

                                                                          Relatedly, the cards (or other unit of note-taking) aren’t intended to be an append-only log. You’re supposed to interact with the system and refine the web of connections as you go, so it may not matter if something is initially orphaned.

                                                                        1. 2

                                                                          https://www.solipsys.co.uk/new/ColinsBlog.html?td22lo

                                                                          I blog about maths, user interfaces, software, people, and other random stuff.

                                                                          Based on the lack of responses I’ve had when I’ve posted things here on Lobsters, I’m guessing very few people would be interested.

                                                                          1. 2

                                                                            I think that the idea of having branch-based conversations, visually, makes sense, as that’s what ends up happening in Twitter or Mastodon, and following threads is equally as hard on both of the platforms.

                                                                            Sadly, this specific implementation has a terrible UX. I would like to see this idea poured into a Mastodon frontend, for example.

                                                                            1. 1

                                                                              Yeah, I agree, it’s a an idea worth exploring even if the execution needs improvement.

                                                                              On the other hand, how is this different from normal chronologically-ordered and indented comment threads like Reddit or here?

                                                                              1. 2

                                                                                I think it can scale better with the conversation. It’s hard to follow conversations in both Reddit and here when it grows too much. The indentation becomes not-so-clear when a thread is longer than the screen’s height.

                                                                              2. 1

                                                                                There is no way forward.

                                                                                It needs a skilled Front-End developer … without that, the idea is dead.

                                                                                I have neither the time nor the interest to become one, and I don’t have the money to pay people. Also, I see no way to make money from it.

                                                                                There is no way forward.

                                                                              1. 5

                                                                                What are some other reasons folks prefer us to the orange site?

                                                                                1. 9

                                                                                  This isn’t an “other” reason, but I like most that there is some level of explanation required on downvotes. I think this makes people more willing to engage even if they might be a little more controversial (the invite-only policy helps control the really wacky stuff). That said, I think there are some users who equate “I disagree with” with “incorrect,” which I disagree with and is incorrect. I’ve always had the policy that I simply won’t upvote something I think is wrong; I’ll only downvote something I know is wrong.

                                                                                  Aside from that, though, it’s really the high S:N that keeps me coming back. I’ll glance at Orange now and then but I’m not even logged in anymore most of the time.

                                                                                  1. 3

                                                                                    I agree with you - it’s a great idea but I wish it wasn’t so in your face. There are many bullshit down votes on lobsters and they still have huge negative connections event hough they are clearly wrong. Take a look at this submission as a prime example.

                                                                                    1. 1

                                                                                      Not everyone agrees on correct and incorrect. Things that may appear obvious to you and things that may appear obvious to someone else can be completely different. If you’re getting a lot of incorrect votes, and you think you’re unambiguously correct, perhaps there’s room for a discussion for either you to learn a valuable new lesson or for them. Either way a incorrect downvote is probably better than a flamewar.

                                                                                      1. 1

                                                                                        I haven’t participated in many “flame wars” on lobsters. I don’t generally find that to be the character of discourse here.

                                                                                        Clearly that mechanism works for you, and it’s in the code, so more power to you and in future when I find myself thinking “whiskey tango foxtrot?” about an Incorrect in a case where assigning factual incorrectness seems impossible to me, I’ll politely message in hopes of getting a clue :)

                                                                                    2. 2

                                                                                      Totally agree. This post is the first I’ve ever voted off topic on here. I think people are WAAAY too fast & loose with Troll, Incorrect, etc.

                                                                                      However that’s a very small quibble in an otherwise great big pile of satisfaction I have around this place :)

                                                                                      1. 1

                                                                                        The incorrect flag is often the alternative to a unnecessary discussion without meaningful resolution :). While I get that some people want to duke it out (myself included), it often just clogs up the comments.

                                                                                        1. 1

                                                                                          I don’t agree. I see it being used in cases where factual correctness would be nearly impossible to determine. When it’s used to call out an actual factual inaccuracy I’m all for it, but sometimes I think people use it as a passive agressive “I think your comment is full of crap” signalling mechanism, and I’m not wild about that.

                                                                                          1. 1

                                                                                            Is that better than a 30 post argument back and forth where neither are satisfied because the outcome is probably not fully knowable?

                                                                                            1. 2

                                                                                              I don’t personally have that problem very often. Once in a while I fail to catch myself, but I try to take it to private message when the back and forth counter starts to tick up.

                                                                                              I suppose I could and should do the same with the incorrect thing as well.

                                                                                      2. 2

                                                                                        I have a downvote on one of my comments which is expressing an opinion, and the reason for a downvote was “incorrect”. There’s no way for me to contest or countermoderate, so I will disregard the voting system entirely. Downvotes feel the same as reddit.

                                                                                      3. 8

                                                                                        Mainly for me it is the technical signal:noise here is much better than on HN. While I appreciate the industry relevance of stories about such-and-such company’s IPO, or such-and-such CEO’s being fired, it’s not what I go to a tech aggregator to read. I prefer the densely concentrated technical content of lobste.rs to the broad mix of HN.

                                                                                        Not to mention the comments… reading HN comments is usually painful, while the comments here are insightful and civil.

                                                                                        1. 7

                                                                                          What are some other reasons folks prefer us to the orange site?

                                                                                          I can easily quote the previous reply in a readable way. I appreciate that HN predates Markdown, but some more formatting would be very helpful. Might seem like a small thing, but writing on HN can be somewhat annoying.

                                                                                          Also, stories tend to perform more consistently here than on HN (example). On HN it’s a bit of a gamble, the same story can get 1 upvote or 400; you never know.

                                                                                          1. 4

                                                                                            I appreciate that HN predates Markdown

                                                                                            Markdown dates to 2004; HN launched in 2007.

                                                                                            1. 3

                                                                                              https://news.ycombinator.com/item?id=1 : October 9th, 2006.

                                                                                              Still postdates Markdown, but Markdown took some time to be adopted (as arp242 says).

                                                                                              1. 1

                                                                                                Oh, I thought HN was older. It still predates Markdown’s ubiquity.

                                                                                            2. 7

                                                                                              There’s a few extra features here that go a long way, but not too many that it pollutes the main features. These extras go along way for me

                                                                                              • reply notifications
                                                                                              • preview
                                                                                              • messaging
                                                                                              • sane formatting
                                                                                              1. 4

                                                                                                I’ll add messaging can help keep down the site noise, too. I might use a message if it’s a compliment or something I’m pretty sure only benefits the person I’m replying to.

                                                                                              2. 5

                                                                                                Transparent moderation.

                                                                                                Edit - related to the above, a semi-clear feeling for what’s on-topic. I, for one, am happy not to see random Wikipedia articles submitted.

                                                                                                1. 4

                                                                                                  I have exactly zero interest in, and thus tolerance for, articles about ‘founders’ and startup culture that have exactly zero technical content.

                                                                                                  I don’t see myself ever starting a company, and if I ever do I’m not convinced keeping up with HN is the path to success I’d choose.

                                                                                                  1. 4

                                                                                                    Reply notifications.

                                                                                                    Means you can have a conversation.

                                                                                                    Hack news tends to invite twitter style snarks rather than engagement.

                                                                                                    1. 4

                                                                                                      HN is often too corporate which I hadn’t seen it happen on lobsters yet. Many threads devolve to IPOs and silicon Valley cringy corporate cultures.

                                                                                                      I’m not sure how exactly lobsters discourage it so it might be just because we’re too small.

                                                                                                      1. 3

                                                                                                        People mentioned community feel. I’ll add specific example of the “What are you doing/reading/etc?” threads where people just show up, talk about themselves, support each other, and sometimes connect in interesting ways. It has a sort of small town or neighborhood feel. Hacker News is so big that their Show or Ask threads are like reading a survey of a city’s worth of people. The latter is also why you’ll see more opportunities, though.

                                                                                                        Different strengths and weaknesses.

                                                                                                        1. 2

                                                                                                          I prefer it because the articles are more on topic to programming and development. As for a second reason, I find that people tend to be more civil here. I’m personally a fan of heavy handed moderation around aggressive or troll-like interactions , even if sometimes I get hit with it myself as it keeps the discussion interesting and productive.

                                                                                                        1. 14

                                                                                                          The reason is because log10(2) ≈ 0.3. The shifted powers of two can be written unsorted, as 10^{ n log10(2) } ≈ 10^{ 3n/10 } where {…} denotes the fractional part. { 3n/10 } is periodic with order 10, i.e.

                                                                                                          { 3*0 / 10 } = 0.0
                                                                                                          { 3*1 / 10 } = 0.3
                                                                                                          { 3*2 / 10 } = 0.6
                                                                                                          { 3*3 / 10 } = 0.9
                                                                                                          { 3*4 / 10 } = { 1.2 } = 0.2
                                                                                                          ...
                                                                                                          { 3*9 / 10 } = 0.7
                                                                                                          { 3*10 / 10 } = 0.0
                                                                                                          

                                                                                                          The lexicographic ordering part is a red herring, in fact it’s just the normal sorting order once the powers of two are shifted accordingly.

                                                                                                          EDIT: Oh, and for something closer to home for most of the people on here:

                                                                                                          2^10 = 10^(log10(2) * 10) ≈ 10^(0.3 * 10) = 10^3.
                                                                                                          

                                                                                                          EDIT: Formatted and slightly expanded version of this comment here: https://jo.ie/powers-of-two.html

                                                                                                          1. 1

                                                                                                            Everything you’ve said here is true, and to some extent it does explain what’s going on, but this is what I meant when I said I can do the calculations, and I can show that they’re close, but I still don’t feel that this is “intuitive”. I don’t feel that someone who doesn’t know about logs can see that there’s an inevitability about this, or that with a single, simple observation someone could see how it just flows.

                                                                                                            But you’ve said a few things here that will help me synthesise something - thank you.

                                                                                                            1. 1

                                                                                                              Yeah, “Intuitive” is very much a matter of perspective. My own maths education started from a physics perspective, so for me showing that log10(2) is roughly 0.3, feels almost intuitive enough (but it’s still lacking something).

                                                                                                              I hope the bit I’ve said on mastodon about Equal Temperament / Just Intonation might be useful toward synthesising a proper explanation, because it really feels close.

                                                                                                              1. 1

                                                                                                                I think it is getting close. Someone else has suggested (using words I’d never use in the explanation) thinking about a logarithmic clock circle. I think that’s where I’m going with this, and your comments have helped clarify things.

                                                                                                          1. 1

                                                                                                            Why would brute force only be associated with Caesar cipher, as the diagram implies?

                                                                                                            1. 1

                                                                                                              “Brute Force” can be applied to everything, absolutely everything, with varying degrees of success. As such, having it associated with everything carries no information.

                                                                                                              However, in the case of the Shift Cipher it’s practical and successful (and parallelisable). In other cases it is only successful once other techniques are applied to reduce the computation needed.

                                                                                                              Similarly “Frequency Analysis” isn’t used only in the case of the Substitution Cipher, but that’s where we first meet it, and then it’s a tool we can use repeatedly elsewhere.

                                                                                                            1. 2

                                                                                                              Ack those graphs have various classes of concepts as nodes which really bothers me (systems/attacks/people)

                                                                                                              1. 2

                                                                                                                The nodes are “things to discuss”, and everything you mention there fall into that category.

                                                                                                                But it’s interesting that you say that - I’m developing a larger version of this diagram where the different types of nodes are distinguished, and the nature of the relationship is made explicit. I share your disquiet, and it’s part of what’s driving the design.

                                                                                                                1. 2

                                                                                                                  Makes sense. Thanks for engaging with the comment - I appreciate that.

                                                                                                                  Internal to my research lab (although hopefully someday more openly) we’re working on a graph strictly of crypto concepts, particularly those which are sufficient for/imply the existence of one another. E.g. nodes might be “Random Oracle” or “Zero-Knowledge Sigma Protocol” which both might point to “Fiat-Shamir Heuristic” which might be one node pointing into “Non-Interactive Zero Knowledge” in that they are sufficient for its construction. We also want to encode black-box impossibility results similarly.

                                                                                                              1. 3

                                                                                                                The article advocates asking “why?” instead of merely “how?” (and “what?”), but doesn’t answer any of these questions. I thought I’d at least see an image.

                                                                                                                1. 2

                                                                                                                  Added in edit: I’m getting a lot of mis-understanding, and I really don’t know what to do to ask the question differently. But the down-votes (off-topic) are clear, so I’ll go away and re-think this. I still believe the question I’m trying to ask is relevant and on-topic, so perhaps I’m just not being clear about what the question is.

                                                                                                                  The response has given me much to think about. In particular, I guess I need to read more here to try to work out what the audience is. It would seem that thought-experiments of this type aren’t welcome. Fair enough.


                                                                                                                  I don’t understand your criticism.

                                                                                                                  Yes, the article is asking why. The point is that this is a question that requires either thought or experiment. To provide an answer in the article, or an image of the result, defeats the entire purpose of the question. If you want to know what the result is you can either follow the link in the article, or you can do the experiment.

                                                                                                                  But some people might choose to think about this for themselves, and giving the answer would prevent that.

                                                                                                                  And the question is about the why. Everyone I ever ask seems simply to do the experiment, look up the answer, or tell me how a photocopier works. I was hoping someone would be able to reason out the why you get the result you do, not simply tell me how the copier achieves the result it does.

                                                                                                                  Clearly I’m just not asking the question correctly - only one person has ever understood what I’m trying to ask, and I don’t understand why that’s the case.

                                                                                                                  Deeply frustrating - I was hoping for more from the Lobsters community. But I see now that there are two downvotes, marking this as “off-topic”. I thought this was sufficiently intellectually engaging, but I guess I’ve misjudged the audience.

                                                                                                                  1. 3

                                                                                                                    I found the title misleading. If it had read “Don’t just ask how — ask why”, and then used the mirror photocopy question as an example, that would be one thing. But when I see a headline asking a question, I expect the article to answer it, and this case I was left disappointed.

                                                                                                                    1. 1

                                                                                                                      That’s really interesting. When I see an article asking a question I expect it to be discussed and not necessarily answered. I wouldn’t have expected people to expect articles always to answer the questions in their titles.

                                                                                                                      Useful to see the different perspective. Thank you.

                                                                                                                      Edit: In case an article intends to pose a question without answering it, how should it be entitled?

                                                                                                                    2. 2

                                                                                                                      The question you are asking absolutely requires knowing how a photocopier or scanner works. There’s no deeper philosophical question involved.

                                                                                                                      1. 1

                                                                                                                        The entire point about this question is that I disagree with you here. I believe it is possible to deduce the result without knowing how a copier works, only by knowing its desired behaviour. That is the point of the thought-experiment, and obviously I’ve not made that clear enough.

                                                                                                                        So let me say this: knowing only what a copier is intended to do, and without knowing anything about how it works, can you, through various thought-experiments, deduce what you must get if you copy a mirror?

                                                                                                                        I believe it’s possible.

                                                                                                                        1. 1

                                                                                                                          You get whatever that mirror was reflecting at the time. In this case, some part of the inside of the photocopier.

                                                                                                                          If there is a deeper point beyond that, it’s lost on me.

                                                                                                                          1. 1

                                                                                                                            You get whatever that mirror was reflecting at the time.

                                                                                                                            That turns out not to be the case, and I believe that even knowing nothing more than what a copier is supposed to accomplish, it’s possible via thought-experiments to deduce that. The reasoning is quite tricky, in places subtle, and I’m not convinced my argument is completely water-tight, and that’s why I believe this question is deeper than most people think.

                                                                                                                            1. 1

                                                                                                                              The only subtlety is that the lighsource is angled. My first guess would have been a white mirror surface because I though the light source was parallell to the surface, but of course that would have prevented the CCD from being on the same axis.

                                                                                                                              In any case, it devolves into the technical details on how to implement a photocopier. Mildly interesting, I learned something today.

                                                                                                                              1. 1

                                                                                                                                Certainly it does lead to the question of how to implement a photocopier, but there is still more going on before that. If you implement a good photocopier, is it an unavoidable consequence that they all give the same result when you copy a mirror?

                                                                                                                              2. 1

                                                                                                                                Eh, that is the case, it just happens to be that because of how the picture is pieced together over time, that reflection is always away from the light.

                                                                                                                                I think the reflective nature of graphite plays a role here as a forcing function in copier design

                                                                                                                                I’m now actually curious to see what chain of reasoning you’ve applied to this.

                                                                                                                                1. 1

                                                                                                                                  You have a message.

                                                                                                                        2. 2

                                                                                                                          It’s very much off-topic as it has nothing to do with computing.

                                                                                                                          1. 1

                                                                                                                            Not directly, no, I agree, and I admit that I didn’t realise that this site is so specifically focussed only on computing. Having said that, my colleagues were intrigued by my approach to this problem. As mentioned in another comment, it’s not actually anything to do with how a photocopier works. It’s about deducing behaviour in an unknown context purely from knowing the overall desired behaviour of a system.

                                                                                                                            As such I’d’ve thought it was squarely in the realm of the sort of thing programmers would occasionally have to do, and hence of interest.

                                                                                                                            The options are (a) I was wrong, or (b) I’ve still not figured out how to ask the question in a way that makes it clear what the real question is, or (c) something else.

                                                                                                                      1. 4

                                                                                                                        Wait, you’re Colin Wright? As in “the inventor of siteswap” Colin Wright? Well, this is amazing :D

                                                                                                                        1. 2

                                                                                                                          Er, yes? Well, I was in one of the groups, but yes, I was involved in that.

                                                                                                                          Hello …

                                                                                                                        1. 3

                                                                                                                          Is this only for PhD students? I’d join but the signup requires an academic email, and I haven’t had one since I finished my PhD. I can possibly point to other credentials to prove I’m not a crank.

                                                                                                                          1. 1

                                                                                                                            Absolutely not meant to be a PhD club. You can email hsx at hessix dot com and will get an account right away.

                                                                                                                            1. 4

                                                                                                                              Then you need to change this - from the “User Guide”:

                                                                                                                              Where am I?

                                                                                                                              • A platform for PhDs in math and stat to discuss research.

                                                                                                                              Why do I need to verify my academic email address?

                                                                                                                              • An algorithm uses it to determine if you are a genuine PhD candidate in math/stat.

                                                                                                                              This sounds like it’s specifically and only for PhD candidates.

                                                                                                                              1. 1

                                                                                                                                It’s now open to everyone with an email address

                                                                                                                                1. 2

                                                                                                                                  The “guide” document says:

                                                                                                                                  • Why do I need to verify my email address?

                                                                                                                                    • To reduce spam. If you are a math/stats PhD, please use your academic email so that your username is highlighted as PhD. The email address is only used in the account creation stage.

                                                                                                                                  There are people with math PhDs who do not have an academic email address, so it’s not clear what you’re doing, or why you’re doing it.

                                                                                                                                  I’m not complaining, this isn’t a criticism, I’m just asking what you’re trying to accomplish, how you’re trying to accomplish it, and what happens in other cases. The document, as it stands, isn’t clear.

                                                                                                                                  Are you intending to highlight those who have a PhD in math but do not work at an academic institution? Are you then intending to verify them, and if so, how?

                                                                                                                                  1. 1

                                                                                                                                    Any PhD candidate, holder who still works in academia, or holder who doesn’t work in academia can submit proof of their PhD status during account creation (e.g. link to PhD thesis, university-hosted online profile, etc.) to facilitate verification. Once verified, these users are highlighted on the platform as PhDs. Registering with an academic email makes the verification faster and easier, otherwise it’s not required. I’ll clarify the user guide.

                                                                                                                          1. 3

                                                                                                                            One error that leapt out at me - it says:

                                                                                                                            “The symbol for showing that one set is a member of another set is ⊂”

                                                                                                                            That’s wrong. That’s the subset symbol, and I suspect it’s the symbol that’s right, and the English that’s wrong.

                                                                                                                            The example is right: P ⊂ N ⊂ Z ⊂ Q

                                                                                                                            But these are not members of each other, they are subsets.

                                                                                                                            1. 2

                                                                                                                              Previously with the HN juice: https://lobste.rs/s/dzpi3p/spikey_spheres

                                                                                                                              1. 1

                                                                                                                                Hah - I hadn’t seen that someone had cross-posted it. Sorry.