1. 1

    I was kinda disappointed that it wasn’t about X11.

    1. 23

      A lot of these points seem very opinionated. I share a number of them, but going off and calling everything that doesn’t fit your preferences “insane software” seems rather … meh. “Follow these rules”-articles without any explanations/reasoning aren’t really all that useful anyway.

      “Must be compatible with GNU GPLv3” means that I can never choose an alternative copyleft license, if I so prefer. It seems to me that this enforces exactly the kind of “monopoly” that some of the other points try to avoid. In general, I find the entire FSF-fawning in this article highly off-putting by the way.

      1. 3

        The EUPL 1.2 (see https://eupl.eu/1.2/en/) is compatible with the GNU GPLv3 without being the GNU GPLv3. It’s a hack to enable a one-way relicensing in certain circumstances, but a useful one.

        1. 0

          What if I don’t want my software relicensed to the GPL?

          1. 3

            This is the motivation behind the manifesto:

            In respect to user freedoms, privacy, liberty and software quality we create software according to the following guidelines.

            and this is the reason for recommending (not requiring) the copyleft licenses:

            Copyleft licenses (like GNU GPL or GNU Affero GPL) are strongly recommended because they guarantee software freedoms to every single end-user and prevent possibility that freedom vanishes somewhere in the distribution chain and the user can not benefit from the free software albeit the software is build on originally free source code.

            So if you can dual-license (GPLv3 + your favorite license), what are your objections?

            I would understand if e.g. some „open-source guy“ would disagree with requirement of GPLv3 license and would prefer a permissive license. But it is not a problem, because GPLv3 is not required – you can use e.g. BSD, MIT or Apache 2.0 – all such licenses are OK – it is required only to be GPLv3 compatible.

        2. 3

          Ad opinionated: this is not an exact science, I can not give mathematical proof for the each rule. So it is quite OK if you call it „opinions“. However they are based on experience (circa 14 years of professional software development). There is problem with TL;DR syndrome – such manifesto must not be too long, because nobody would read it. Each item could be an article and the manifesto could be a book… I will probably address particular topics in separate articles later. Currently, there are some additional notes, links and quotations in the source code (in later versions they might go to the footnotes in generated documents, but currently, in the v_0 branch they are just in the source code).

          1. 4

            Ad sane/insane: I understand that it is bit controversial, but it is not meant to be offensive. It should avoid the worst cases – if someone tells me to run curl http://www.example.com/install.sh | sudo bash in order to install his software, then yes, it is insane. Same case is that if so many free software projects depend on a single corporation. Or if you need a disproportionately complex (LOC, cyclomatic complexity, dependencies) software for doing a simple job. The complexity is real problem and despite it seems working now, it is still insane to depend on such software. BTW: today, the post just delivered me a copy of the book Click Here to Kill Everybody which seems to be a good read and relevant to this topic.

            1. 4

              Ad sane/insane: I understand that it is bit controversial, but it is not meant to be offensive. It should avoid the worst cases – if someone tells me to run curl http://www.example.com/install.sh | sudo bash in order to install his software, then yes, it is insane.

              I think your use of the word “insane” is insane.

              1. 2

                Maybe it would work better if you negated the logic, that is to collect list of all insane examples, like in The Little Book of Python Anti-Patterns book.

              2. 2

                I can never choose an alternative copyleft license

                The software might be dual-licensed. It can be e.g. GPLv2 and GPLv3 (which differs from the GPLv2+ because it does not include the GPLv4 and later which is not known yet) or any other license + GPLv3.

                I find the entire FSF-fawning in this article highly off-putting by the way.

                I am a FSF associate member, but I am not happy with the recent events (see my article Future of the Free Software Foundation). However the Sane software manifesto is much older than those events and is written independently from the FSF. It rather refers to particular original ideas than to the current FSF (because such organization might change during time). It should work as a stand-alone document without any references to mutable external sources (such sources are usually quoted thus change in the external source does not automatically mean the change in the Sane software manifesto).

                1. 4

                  I’m not sure how to state this more plainly: I don’t like the GPL. I don’t want software I write available under the GPL. I don’t want “alternative solutions”, I don’t want the GPL. It’s really that simple.

                  Recent events regarding the FSF have nothing to do with my dislike for it; that’s mostly fuelled by articles such as this one which state One True Way™ without any nuance or appearant understanding of other viewpoints or why things are as they are (your other comments, instead of adding nuance, only doubled down).

                  But hey, guess I’m “not sane” 🤷 Let me be plain about that as well: saying that people are “insane” for disagreeing about a particular topic – especially political ones like GPL/Free Software – is insulting, offensive, arrogant, and highly toxic.

                  1. 5

                    I’d like to enter the discussion right here.

                    Let me be plain about that as well: saying that people are “insane” for disagreeing about a particular topic – especially political ones like GPL/Free Software – is insulting, offensive, arrogant, and highly toxic.

                    While I do have my own objections against this manifesto (including its name, the fact that it’s even called a manifesto, and the majority of its content), there are two important points to be made. First of all, he’s calling the software “insane”, not its authors. But what’s even more important is that the English word “sane”, and especially the opposite term, “insane”, sound maybe more harsh than intended. Franta is Czech and translates the word as “příčetný”, which has somewhat milder connotation. That’s not to say it didn’t cause some controversy on the Czech Internet, because it for sure did, but it’s not per se insulting. It’s more that people just don’t agree with it.

                    Anyway, like I said, I do have my own objections about this manifesto, but I believe this particular statement of yours is just a cultural misunderstanding. There are some nice suggestions in this discussion (sensible or decent), so perhaps Franta would consider renaming it.

                    1. 3

                      I wrote about my own struggles with English as a non-native speaker before, so I certainly have a lot of sympathy and patience for that. The thing here is that people did tell the author, which was then ignored. So, I opted more a more direct approach to ensure the message got across with little chance of misunderstanding.

                      While less strong words – like “sensible” or “decent” – would certainly be an improvement, I still think this manifesto is far too opinionated and political to claim anything that doesn’t abide by it as “insensible” and “indecent”.

                      he’s calling the software “insane”, not its authors

                      I appreciate this, but there is a very fine line here; if I make “insane” software, then does that not imply that I’m acting in an “insane” way? And if I’m acting in an “insane” way, then am I not “insane”?

                      1. 3

                        Yes, I think it should be written in a different form. I hesitated to do it, but in the end decided to post my opinion.

                        I’ve read tons of Franta’s comments about similar topics and agreed with him a lot, yet was rolling my eyes when I read this. That’s perhaps the simplest way to put it. I understand his logic, but… OK, here’s another way to put it: Mixing tech with politics can do no good. After 9 months on Lobsters, I encountered first deleted comment right here. It’s my fault I didn’t realize I was entering a purely political thread, not Franta’s, but it still shows the level of controversy it causes.

                        The world needs good developers who follow good practices, not more labels. We can try to create some sort of “standard” for software development, but calling most of the software in existence “insane” is pointless, because it’s not going to change much. If anything, it should be split into multiple standards. We already have a definition of free software, so we could add some definitions for well-tested software, well-documented software, well-managed free software etc. But that just runs into similar problems. Testing games is so much different than testing enterprise systems… I would repeat myself at this point :)

              1. 3

                The community is generally unhelpful and hostile (save for Reddit and SO, generally). Beginners are often treated as unworthy of help.

                Compared to what exactly? I’ve used multiple languages and in my opinion, python community is among the more friendly and actually helpful most of the time.

                1. 1

                  The author seems to have updated their post, but not actually made it any clearer what the issues were. My experience is like yours. [Update: I found http://cryto.net/~joepie91/manual.html based on a search. Therefore, I’d suggest the author’s experience is unsurprising, if that is indeed the approach.]

                  I have seen people fail to understand any of the history or context behind how we end up with the current state of Python. They’ll typically attack the GIL, or some other aspect of the language which Pythonistas already understand is less than optimal. In my experience, Pythonistas tend to be very pragmatic and want to get on with what they are building versus engage in these conversations. In response they get treated like “they aren’t even smart enough to know what is wrong with their language”. This is infrequent in Python communities, but Smart Aleck’s try it from time to time. It’s almost the first post on Hacker News.

                1. 3

                  Holy crap this is true. I very vehemently dislike PHP but always found what I needed in its documentation, and readily found usage examples.

                  Python is my language of choice, but both the language docs and docs from the community tend towards being very incomplete and have very few solid examples.

                  Take argparse for example. The documentation page for it is LONG, and complicated, but actually does a rather poor job at explaining how to actually use the thing. Witness the 5 argparse tutorials out there on the web that try to get people started in a reasonable way.

                  It’s a shame, really. Python is easy to learn as a language and really is a great starter platform, but the entire community needs to embrace the importance of truly superlative docs.

                    1. 1

                      I mean, there are a zillion things that do a different / better? job at handling argument parsing. Here are a few:

                      Click

                      Fire

                      The list goes on and on.

                      It’s not that we’re stuck with argparse, it’s that argparse’s documentation is actively user hostile and people end up turning to alternatives when argparse would probably work just fine a lot of the time.

                  1. 2

                    I always thought that was pretty clever.

                    That was actually pretty stupid, on so many level I don’t even go to details.

                    1. 23

                      This isn’t Hacker News, if there are reasons it’s stupid, we go into why it’s stupid :P

                      1. 0

                        I did that immediately in my second comment.

                        1. -1

                          This morning, I thought of saying the same thing about trivial dismissive comments in response to your comment here.

                          1. 3

                            I’m sorry, what? How is saying “I found a part of confusing” in any way similar to “this is stupid on so many level I don’t even go to details”?

                            1. -5

                              I was following it up until the linear logic part; I think the first principles of LL could be explained better here.

                              This isn’t Hacker News, if there are reasons the first principles can be explained better, we go into how it can be explained better :p

                        2. 4

                          Oh yes, I think the same. So much that can go wrong with physical devices. Imagine someone lightly touching the arm and getting it out of alignment.

                          Note that you can just attach a USB mouse to an iOS device and click buttons with that. USB mice are easy to emulate in software.

                          1. 1

                            Thats one thing. Second is that you could just run the whole app in emulator. Or decompile it and just cut the approving routine from it. Whole

                            There was no programmatic way around this.

                            is just a failure of imagination. Off-course, best solution would be to run this through management and force them to remove this bullshit altogether.

                            1. 11

                              Or decompile it and just cut the approving routine from it.

                              Yes just reverse engineer a banking application and hope you don’t mess anything up. It’s just money, nothing serious could happen if you introduce bugs.

                              Also, from the post:

                              we couldn’t just run it in a simulator

                              Maybe don’t make so many assumptions about the author or their problems. For all you know, they exhausted all the reasonable options before resorting to this tomfoolery. Or this technique was used as a stopgap while coming up with a more robust solution. Or they simply didn’t have the time to do better. A business runs on money, not perfectly elegant solutions.

                              1. 6

                                You’re imagining this was a technical constraint on their side. It might have been a legal or contractual constraint.

                                1. 5

                                  The approval was software-based, but in a closed system. The approval mechanism ran in a third-party iOS application, and we couldn’t just run it in a simulator.

                                  I’m assuming there were considerably more constraints going on that make the “obvious” solutions in applicable.

                                  1. 4

                                    Those are some pretty big “just”s!

                                    Personally, since it’s presumably a capacitive touch screen, I’d attach a wire to the correct area of the screen, and hook it up via a relay to a wet sausage. It would require weekly maintenance, maybe more in warm weather.

                                    1. 3

                                      This kind of armchair quarterbacking isn’t helpful. You could have rephrased all of your points as questions to find out the situation: “I wonder why they didn’t run this through management…” Not only does this make your comment less hostile, it opens you up to learn (as @saturn said, it might have been a legal requirement). Assuming you haven’t changed your mind after learning the full context, you might be able to persuade people that an assumption they held isn’t actually true – that’s how you provide technical advice on something you didn’t build without pissing off the creators.

                                        1. 3

                                          IMO some of the best empirical evidence in favor of static types is how many people are fans of mypy and typescript.

                                          1. 3

                                            Uhm… That just measures hype, it tells absolutely nothing if it actually provides value. Programmers like new toys :-)

                                            1. 1

                                              And also .. how many people are actually fans of mypy and using it? How big percentage? Because I wouldn’t really say that it is that many.

                                            2. 3

                                              To be more precise, I would call that empirical evidence in favor of gradual types. I typed the whole Oil frontend with MyPy and it worked quite well [1]. (Oil will eventually be a totally statically typed program, but it’s still in an intermediate state now.)

                                              But I still want to start with a dynamic language. Basically because I’m “reverse engineering” shell by observation – I would call it schema discovery. Writing types at first doesn’t make sense because I don’t know what they are. I have to write some code to figure that out :)

                                              Although Oil is an unusual project in some respects, I don’t think it’s unusual in this respect. I would say this situation is probably more common than people realize. “Observing the world before modelling it” seems to be the common thread. Data science is an easy example: you get a bunch of real world data and you can’t make assumptions it before writing code.

                                              Another really common situation is that your types live outside the process / language. For example, an SQL database has its own types, and common distributed systems tools like protobuf/thrift/capnproto have a language-independent notion of types.

                                              Big distributed systems are more like “observing the world”, not modelling it. That is, the stuff on the other side of the wire might have been written 15 years ago, and you don’t control it, etc.

                                              [1] http://www.oilshell.org/blog/2019/06/13.html

                                              1. 0

                                                Writing types at first doesn’t make sense because I don’t know what they are. I have to write some code to figure that out :)

                                                Having a static type system and needing to write types are two different things. A language with type inference can check that your code type checks without requiring types to be written explicitly. People often equate static typing with manifest typing, and due to that misconception people often think that static typing just gets in the way.

                                                1. 2

                                                  You equate having to write types out with having to know them. I write plenty of code without explicitly declaring types while still paying the cost of having to think about them. We’re not living in an utopia where structural typing is the default.

                                            1. 7

                                              This is pretty cool. I just don’t understand your insistence that it’s all about the tree notation. I’d love to see a proper description of the grammar. It seems to have echoes of OMeta.

                                              I just noticed the link to https://github.com/treenotation/jtree/blob/master/languageChecklist.md. The notation for grammars seems quite barbaric. But maybe I just don’t understand. A more elaborate write-up than a checklist may help.

                                              Tree Notation is helpful for lexing. But your demos inevitably have a lot more than lexing. Either you need to treat them as first class research objectives. Or you need to make it easy to tease apart all the moving parts, by say showing how the same language is implemented with the same grammar language in tree notation vs a more conventional lexer.

                                              1. 10

                                                I just don’t understand your insistence that it’s all about the tree notation.

                                                I know I’ve done a lousy job so far at explaining what I see. I gave a talk 2 years ago about thinking about source code in 2 and 3 dimensions. You can definitely do this type of language in traditional manners with parsers that have colons and semicolons and brackets etc, but my insistence is none of that is necessary. Our mission is to rid the world of unnecessary complexity (while leaving art untouches :) ). For reference, Dumbdown took me approximately 50 minutes from idea to shipping an MVP with autocomplete, syntax highlighting, parsing, type checking, compiling, and unit tests. And the code is relatively timeless. I know I am not doing a good job at explaining why Tree Notation makes this possible, but I hope empirically the data points will start adding up, and maybe people smarter than I am can explain it better.

                                                I’d love to see a proper description of the grammar.

                                                The Dumbdown grammar is 84 lines long. It it written in a Tree Language called Grammar. Grammar is written in itself and is 300 lines long: https://treenotation.org/designer/#standard%20grammar (though at the moment the compiler for Grammar is still written in TypeScript).

                                                The notation for grammars seems quite barbaric.

                                                I’ve gotten super fast with it but there’s lots to be improved. The “Infer Grammar” button on the designer app can be helpful. But really I should record some demo videos or something for now, until it’s good enough that it is self explanatory.

                                                But your demos inevitably have a lot more than lexing. Either you need to treat them as first class research objectives. Or you need to make it easy to tease apart all the moving parts, by say showing how the same language is implemented with the same grammar language in tree notation vs a more conventional lexer.

                                                An immense amount of work to do. The goal is to build a movement that can do these sort of things. Tree Notation now is about where the Web was in ~1989. Just at the very beginning. There are endless applications of this. We need help with all the things. Perhaps the biggest help of all would be someone better than me at organizing the helpers :).

                                                1. 6

                                                  I think you should set aside time to explain what it is, how it works, and with examples. It’s worth having an accessible description of the thing you spent years on if you’re trying to present it to others. The submission makes me think you are. So, definitely make something that lets us know what Grammar is and how it works. Then, people can start making comparisons, experimenting, etc.

                                                  You might also find Ometa, TXL, and Rascal interesting.

                                                  1. 3

                                                    I think you should set aside time to explain what it is, how it works, and with examples.

                                                    This is very good advice and feedback. I think the problem is I’m trying to do this, and now have papers, FAQs, blog posts, demo apps, source code, over a dozen sample languages, and I’m still doing a terrible job at it. Here in person at the Cancer Center coworkers are able to explain it to new people better than me. I think we just need to find someone who is great at visuals, youtubes, or whatever, to lead a better explanatory site. I could work on improving my skills in that domain (and I will keep improving), but there’s still so much work to do on the programming end that if we could find the right collaborators to lead that sort of site, that might be the more efficient approach.

                                                    Yes, Ometa, TXL, and Rascal are all ones I studied. Thank you for pointing those out. Often when someone mentions something, even though I may have studied it at one point, it’s a great signal that I should go take another look to see what things I missed. Thanks.

                                                  2. 4

                                                    What would you say is the type of person that can see what you see? I’m basically just a techy Joe Schmoe but I find it easier to understand M theory than your work on Tree Notation. Do I have to have a PhD in math/cs to understand this stuff?

                                                    1. 4

                                                      Do I have to have a PhD in math/cs to understand this stuff?

                                                      Well I only have a bachelors in Economics (and flunked out of college once), so I guess that would mean no.

                                                      What would you say is the type of person that can see what you see?

                                                      I just stumbled upon this notation which seemed a simple way to do things. I asked people much smarter than me for years for help and guidance and whether they thought it would be useful. No one thought it was interesting but no one could explain to me why it wasn’t. So I spent years and years trying to find flaws in it, and thinking of all the places where it could help. So I have about 7 years or so of thinking about this and researching it somewhat obsessively. I built a database of 10K+ notations and languages with 1k+ columns and there’s not a single instance found where another notation or language can do things simpler than Tree Notation (by simpler I mean with fewer parts). I built crude hardware that could operate directly on Trees (instead of our register based models of computing). I built 3-D models of programs (copying the research techniques of watson and crick). I even spent 2 months trying microdosing to figure it out.

                                                      And I’ve probably made some obvious dumb flaws but there’s something interesting here. I bet today’s version is garbage to the version that is out in 1 year.

                                                      Anyway, so what type of person does it take to see what I see? A really dumb stubborn person I guess.

                                                      1. 5

                                                        The Dumbdown grammar is 84 lines long. It it written in a Tree Language called Grammar. Grammar is written in itself and is 300 lines long: https://treenotation.org/designer/#standard%20grammar (though at the moment the compiler for Grammar is still written in TypeScript).

                                                        Are you familiard with paper STEPS Toward The Reinvention of Programming and generally VPRI?

                                                        1. 3

                                                          Yes, I’ve read that paper a couple times and am familiar with VPRI. Alan Kay’s ideas have very much helped me along the way. I don’t believe I’ve talked to anyone from VPRI though (or the later YC backed lab that did similar work). Thank you for mentioning that again. I’ll give it another look.

                                                        2. 4

                                                          “Well I only have a bachelors in Economics” “So I spent years and years trying to find flaws in it, and thinking of all the places where it could help. So I have about 7 years or so of thinking about this”

                                                          You’ve put about a Ph.D.’s worth of time into this, though. It might be harder out of the blue than you realize.

                                                          1. 4

                                                            You’ve put about a Ph.D.’s worth of time into this

                                                            I laughed out loud at this. I never thought of it so succinctly. You got me thinking and I did a Google search for “Can you get a PhD without going to graduate school?”. Looks like such a thing might be possible, but only in the UK where it looks like if you have some peer reviewed papers you can apply for a “phd by merit”. Not sure if that’s accurate, just what a quick Google search.

                                                            It might be harder out of the blue than you realize.

                                                            I realize it’s really hard. I’ve done thousands of experiments on Tree Notation and many more experiments that I’ve just “run in my mind” over the years. So I see what it will become. (And that’s if there isn’t some fatal flaw that I have overlooked, which I still has at least a 10% probability of happening). So I’ve envisioned all the use cases, the benefits, and how to overcome the challenges. Only now are things starting to get good enough where other people are seeing the potential.

                                                            Here at the Cancer Center I no longer explain it to people when I can help it, letting instead other people at the lab explain it who have far less experience with it than me. They do a better job at explaining it. I’m hoping we find one or more people who are good ad visuals and communicating and could build us a new website (https://www.reddit.com/r/treenotation/comments/cyjfpy/wanted_someone_to_redo_the_treenotationorg/) to explain it better. Pull requests are also welcome.

                                                            1. 3

                                                              I’ve gone through your website and previous posts in the past, and I legitimately had a false memory in my mind (until you corrected it) that your website said you were working on your PhD. Very strange.

                                                              1. 3

                                                                Hmmm. I have toyed with pursuing it, but the way the system is setup in the U.S. doesn’t really make sense. Seems more like indentured servitude than science to me :)

                                                                This is kind of out of left field, but I’m very much against what some wise people call “Intellectual Slavery” laws of copyrights and patents, so it would be hard for me to stomach going along with a system of closed access journals, expensive textbooks, etc. And like I said, I already flunked out of school once so I just don’t think it’s a good fit :).

                                                                My wife has a PhD though and so do most of my coworkers (some of them are phd students). Do you have one? Would you recommend it? I’m kind of curious if there’s a way to do it that would make sense, perhaps outside of the US.

                                                                1. 2

                                                                  I’m nowhere near having a PhD so unfortunately I can’t give any advice from my own experience. From what I’ve seen though, a PhD is only really good for academia/research (even in CS) so I feel like you probably wouldn’t benefit from it, all things considered. You would probably get better advice from your wife and coworkers though :p

                                                        3. 4

                                                          You seem open to some feedback, so, here’s some of mine, as someone who’s looked a couple of times at Tree Notation and still hasn’t quite “got it”. I’ve just spent the last 20 minutes looking again at various parts of the site.

                                                          (Before I go any further, please be assured this is meant with the best of intentions, and no malice. I feel like there’s something here, and a lot of work has gone into it but somehow I’m not getting it - and I’m not sure what steps I would need to take to get there).

                                                          1. The “What is Tree Notation?” on the front page doesn’t explain what it is, except for the hint “Tree Notation is an error-free base notation like binary”. But I don’t really know what that means.

                                                          2. “Tree Notation […] is grounded in 3-dimensional geometry” (again, from the front page) doesn’t mean anything to me at this point. Honestly, it made me think of Time Cube. I’m sure there’s something there, but I feel intimidated by the idea that I need to understand something mathsy to use Tree Notation. I think I have completely misunderstood what this sentence means, but I also have no idea what it means.

                                                          3. The example with package.json looks like an alternative syntax for JSON. I think the point is that you can write a syntax for JSON itself in Tree Notation? Which makes it like… JSON Schema? What’s the comparison to something I might be familiar with?

                                                          4. The Lisp example is basically the same. It just looks like an alternative grammar: S-Exps without the parens. It’s not obvious how or why this is useful.

                                                          5. On the Grammer section of the front page:

                                                          You can write new Grammar files to define new languages. By creating a grammar file you get a parser, a type checker, syntax highlighting, autocomplete, a compiler, and virtual machine for executing your new language.

                                                          You know, I’d probably lead with this. I think it’s the most concrete information on the page

                                                          1. In the “Who this Library is For” section, I’m unclear what “this Library” is at this point. Is it everything I need to write a language? Is it a parser for tree notation?

                                                          2. The checklist is halfway to being a tutorial. It would be good if it explained the “why” as well as the “what” (and be careful about snipping previously-seen code out of the examples in the tutorial. Much better, IMO, to show all code and note what has changed from the previous block than to elide the code and expect people to remember what it was - don’t make me think ;) )

                                                          For reference, Dumbdown took me approximately 50 minutes from idea to shipping an MVP with autocomplete, syntax highlighting, parsing, type checking, compiling, and unit tests.

                                                          A walkthrough tutorial for putting this together would probably be super helpful and cool.

                                                          Here at the Cancer Center I no longer explain it to people when I can help it, letting instead other people at the lab explain it who have far less experience with it than me. They do a better job at explaining it.

                                                          Maybe get those written down? Or see if there are common ways it’s being communicated by these people that aren’t currently on the site.

                                                          1. 1

                                                            as someone who’s looked a couple of times at Tree Notation and still hasn’t quite “got it”. I’ve just spent the last 20 minutes looking again at various parts of the site.

                                                            Thank you very much for taking the time. Truly grateful. This is such good data that the current docs are just not doing a good job. I’m thinking perhaps we need to take a much more “show vs tell” approach, with videos, screenshots, animated gifs, visualizations, demos up front, etc, and move the text and FAQ.

                                                            Before I go any further, please be assured this is meant with the best of intentions, and no malice.

                                                            You are too nice!

                                                            1. on the front page doesn’t explain what it is,

                                                            Good point. The more I think about it the more I think the front page should all be show versus tell.

                                                            1. Tree Notation […] is grounded in 3-dimensional geometry” (again, from the front page) doesn’t mean anything to me at this point.

                                                            This just means that programs have a 3-D representation. Think of them like molecules. Here’s a video of a talk I gave 2 years ago (https://www.youtube.com/watch?v=ldVtDlbOUMA) that might clarify that more. It was at JSConf 2017 in SF, I’m looking for the actual video and not just my screen recording, but can’t find it. With traditional languages the first step in parsing is to generally strip whitespace and turn the code into a 1D sequence. Your code is not mapped into the 3D world. With Tree Notation it is, and there’s a location of each word/line, and changing that changes the meaning of the program. It’s like a design constraint. Tree Notation programs in a sense need to obey the laws of physics (I know that’s an inaccurate cliche, but might hint at what I’m getting at?).

                                                            it made me think of Time Cube

                                                            I’m not familiar with that one, but I totally understand the feedback that this is “A New Kind of Science” type of thing. That’s why I spend most of my time on code, tooling, data gathering, products, user tests and demos and putting the theory into practice, and comparatively little of my time on papers and theoretical work. I’ve tried to see where others who have stumbled upon something similarly simple and perhaps profound have erred. A New Kind of Science has been very influential to me in particular as an experiment of what would it look like to go all in on the theoretical aspect, and my takeaway from that is that it’s a brilliant 50-100 page book, but then it just goes way to far out on a limb and so the priority when dealing with a new library should be to slowly and incrementally build up the tooling to bring practical benefits from the work out early, while putting the theoretical implications as a lower priority. Not descending into madness, while not staying totally practical, while also not listening to people who are trying to disparage the work by saying you are descending into madness, it’s a tricky balance to maintain but I’ve got some good strategies built up to walk that line :)

                                                            The example with package.json looks like an alternative syntax for JSON. I think the point is that you can write a syntax for JSON itself in Tree Notation? Which makes it like… JSON Schema? What’s the comparison to something I might be familiar with?

                                                            The Grammar Tree Language is sort of like JSON Schema. I just updated that example a bit with more information. Tree Notation is very low level (think binary or ascii). The Tree Languages can do anything (so you can have a Tree Language that maps to JSON like the Dug demo language, or you can make a Tree Language for building languages like Grammar, or you can make a general purpose Tree Programming language, etc). The idea is none of those things require parens or brackets or colons etc. Simple positioning in 3D geometry is the only thing we need to do all of the things that we traditionally use syntax for. Positioning gives you abstraction, scope, trees, etc. The building blocks for everything else.

                                                            The Lisp example is basically the same. It just looks like an alternative grammar: S-Exps without the parens. It’s not obvious how or why this is useful.

                                                            If you look at any one example you can say they all are only incremental improvements. It’s all about the network effects. I did not write syntax highlighting for my lisp like Tree Language. I wrote it for my HTML Tree Language. But It works for both. Etc. If you master the basics of Tree Notation syntax (maybe there’s like 5 rules? I’m not sure how many but it’s less than 10 for sure), you understand the syntax for now dozens of languages (and hopefully in the future, thousands). The semantics you need to learn from that domain, but hopefully we eliminate one large category of mistakes and confusion.

                                                            1. You know, I’d probably lead with this. I think it’s the most concrete information on the page

                                                            Good idea. Thanks! Will probably do that in the new version.

                                                            1. In the “Who this Library is For” section, I’m unclear what “this Library” is at this point. Is it everything I need to write a language? Is it a parser for tree notation?

                                                            This is a common point of confusion. We should reorganize it so there’s the Tree Notation landing page, and then there’s the JTree Landing page (the tree notation library for TypeScript/Javascript). In the new redesign, we’ll remove the Jtree specific stuff and instead add links to all the different implementations, similar to json.org.

                                                            1. The checklist is halfway to being a tutorial. It would be good if it explained the “why” as well as the “what” (and be careful about snipping previously-seen code out of the examples in the tutorial. Much better, IMO, to show all code and note what has changed from the previous block than to elide the code and expect people to remember what it was - don’t make me think ;) )

                                                            Good feedback! Thanks. Someone is volunteering to do a new one. Hopefully he’ll post that soon.

                                                            1. A walkthrough tutorial for putting this together would probably be super helpful and cool.

                                                            Noted. Will add..

                                                            Maybe get those written down? Or see if there are common ways it’s being communicated by these people that aren’t currently on the site.

                                                            Great idea. I just sent an email to the lab folks. Will add.

                                                          2. 3

                                                            Yeah, videos would be great.

                                                            How quickly you can use it is not a great signal, because it’s your baby and you’ve created it from scratch. Needs more hallway usability testing.

                                                            1. 2

                                                              Needs more hallway usability testing.

                                                              Yeah, it’s painful in this regard. Yesterday’s designer launch addressed a number of the most common issues, but still the list of things to do and user requests is a mile long. The in person community here is very helpful, but hoping we’ll be able to get a community going of remote contributors in the months ahead.

                                                              How quickly you can use it is not a great signal

                                                              Agreed. It’s what I have though, until the tooling gets better. I guess the promising signal though is that this sort of thing would have taken me 10 hours or more 6 months ago (speaking in rough estimates), so the trend is in the right direction.

                                                            2. 2

                                                              There’s a thing at work we’re currently representing rather clumsily with JSON that I’ve been wanting to find a better encoding for. Defining a tree language for it, and a back-and-forth converter between tree notation and the current JSON might be a cheap experiment to see what it’s all about.

                                                              If tree notation is as useful as you make it sound, that could be a huge productivity boost. It sounds like it could make it easier for people to edit these structures by hand, to write more advanced features for the visual editor, create automatic transformations of common patterns, and so on.

                                                              You have me intrigued.

                                                              1. 1

                                                                Please do let me know how it goes.

                                                                I apologize in advance for the difficulty as the current state of things is early, but appreciate any help toward making things better for the future community!

                                                          1. 1

                                                            Flagged as off-topic. This is an interesting experiment for you personally, but it’s probably not as interesting for the community.

                                                            1. 1

                                                              I thought that info about the stuff I am doing at the moment may be interesting to some, but fair enough.

                                                              1. 1

                                                                Offer an RSS feed (maybe you already do), or post updates of new posts to Twitter or similar.

                                                            1. 5

                                                              I can’t remember who said it but I always liked the description of C as “universal assembly language”.

                                                              I love C, I’d say 50% of the code I write is in C. The other 50% is in Python. I think, though I’m not sure, that it’s going to eventually be 50/50 Rust/Go. The future is coming.

                                                              (Along with the occasional assembly language, of course. I’m interested to see what architectures we come up with as silicon real estate gets less expensive. Intel was banking on almost-operating-system-on-a-chip with iAPX 432, maybe we’ll get there eventually.)

                                                              1. 5

                                                                I can’t remember who said it but I always liked the description of C as “universal assembly language”.

                                                                I’ve never really liked that, because it gives people some incredibly misguided ideas about how C works on modern compilers and CPU architectures.

                                                                Essentially people naively assume that they can predict what C “naturally” compiles to, and claim this as an advantage of C, when in fact they’re just assuming they have a grasp of what the compiler and CPU are doing when both are frequently doing something else entirely that’s faster but happens to preserve the semantics.

                                                                1. 7

                                                                  Look at Mr. I-Can-Afford-Something-Better-Than-A-PDP-11 over here.

                                                                  1. 1

                                                                    Hey, I’d love to be able to justify buying a working PDP-11. Found one for sale for about the price of a high-end laptop.

                                                                  2. 3

                                                                    Dont forget D, Nim, and Zig. Especially D given its maturity and compile speeds.

                                                                    1. 11

                                                                      Don’t get me wrong, but I feel like D has been “almost there” for like 20 years now.

                                                                      (Fun fact combining my love of computer science and the history of western religion: “Nim” was originally named “Nimrod”. Nimrod was “a mighty hunter before YHWH” (the tetragrammaton, there’s a lot to discuss there, along with the exact meaning of “before”) in Genesis. “Nimrod” became an insult in English when Bugs Bunny mockingly called Elmer Fudd “a mighty hunter” and a “Nimrod” in a cartoon in the 1950’s.)

                                                                      1. 6

                                                                        Re D. The licensing situation caused a lot of it. Now, they have a lot of features, a fast compiler, and a compiler for faster executable. Maybe it just needs a killer app or big company backing it.

                                                                        Re Nim. I knew about Nimrod. I assumed the negative connotations were why they changed the name. I never checked, though.

                                                                        1. 8

                                                                          The licensing situation caused a lot of it.

                                                                          RIP REBOL

                                                                          1. 7

                                                                            RIP REBOL

                                                                            Fortunately, there is the Red programming language

                                                                    2. 2

                                                                      I think, though I’m not sure, that it’s going to eventually be 50/50 Rust/Go

                                                                      Both languages make a lot of sense and I can imagine smart companies having this kind of mix (with some JS or python added, probably). But it looks like a strange mix for a person in my opinion.

                                                                      If you manage to maintain the ability and mindset to efficiently code in Rust (which is a real burden), is there really a reason to write anything in Go ? I don’t see one but I’d welcome your argument.

                                                                      1. 1

                                                                        If you manage to maintain the ability and mindset to efficiently code in Rust (which is a real burden), is there really a reason to write anything in Go ? I don’t see one but I’d welcome your argument.

                                                                        Perhaps you are hoping for contributors who haven’t learned to live with the borrow checker. Perhaps your program is fairly simple, and you want to distribute cross-platform binaries (for cross-compilation, rust is better than C, but light years behind go)

                                                                        1. 1

                                                                          Depends on how well one knows/likes Go, really. I’m not good enough at it to think of it as replacing Python for quick-and-incremental tasks, but I could see where others might.

                                                                        2. 1

                                                                          I’d say 50% of the code I write is in C. The other 50% is in Python.

                                                                          For me it’s 50% C and 50% Go. I like working with types too much.

                                                                        1. 11

                                                                          Note that Intel get paid according to the number of CPU cycles consumed to do any given task…

                                                                          In all seriousness, sometimes I wonder about how C has influenced chip design and how much Intel has benefited from it. C makes it easy to dereference memory locations, which is actually quite an expensive thing to do, and the proliferation of this type of programming ends up requiring a lot of CPU caching, prefetching, out of order execution while waiting for memory to arrive, and ultimately, hyperthreading to allow a core to make progress while waiting for memory. If all code had to be written in assembly, we’d probably end up with simpler data structures that are faster to execute and much simpler CPUs.

                                                                          1. 3

                                                                            In all seriousness, sometimes I wonder about how C has influenced chip design and how much Intel has benefited from it.

                                                                            Related: https://queue.acm.org/detail.cfm?id=3212479

                                                                            1. 2

                                                                              If you data structure requires heap/non-continuous memory access to implement it, you do it in any language. Yes, people did that in assembly days too: semantically it’s not any harder than in C.

                                                                            1. 1

                                                                              Nice. I am trying TabNine for some time and I quite like it so far.

                                                                              1. 1

                                                                                One of those weird git hosting sites that don’t put code first. And that file browser’s is really bad. Who sorts files and directories alphabetically? Usually you put directories first.

                                                                                1. 2

                                                                                  And that file browser’s is really bad. Who sorts files and directories alphabetically?

                                                                                  I feel this isn’t totally fair. There’s a big red box on the front page that makes it quite clear that it’s early days for development:

                                                                                  Achtung! Sourcehut is still under heavy development, and while many of the services are usable, expect to find lots of missing polish, broken links, incomplete docs, and so on. Here be dragons!

                                                                                  Why don’t you submit an issue?

                                                                                  1. 1

                                                                                    I feel this isn’t totally fair. There’s a big red box on the front page that makes it quite clear that it’s early days for development

                                                                                    Fair to who? Its just obvious flaws.

                                                                                    Why don’t you submit an issue?

                                                                                    I don’t really care.

                                                                                1. 3

                                                                                  I can recommend Dealers of Lightning to anyone interested in Smalltalk and history around Alan Kay.

                                                                                  1. 18

                                                                                    One day, I read a book called Daemon (by Daniel Suarez). Its year 2010 and I begin to think about the infrastructure and architecture of the Daemon.

                                                                                    I like personal wiki software, and I am trying to reconcile something like three to five places where I write my notes into one place in computer shared across all devices I own at that time. I have this beautiful idea; lets make decentralized infrastructure that will allow you to work with structured data. It should also be a personal wiki. Tool which you can use to write your personal notes, use it to generate your homepage, but also to interact with all feeds you use and generate (everything from jabber, irc to last.fm feed and catalog of your movie ratings on imdb), index them and work with them with all of your programs. Websites? Pfffff. Just write an API for them and mirror them in this tool, so you can build custom views on the comment streams and whatnot! It will be glorious.

                                                                                    So I start to learn Rebol, because it seems to be really ideal for this kind of tool. I read everything there is about Rebol. I don’t mean it figuratively, but literally. I’ve read all books, all articles I could find and most of the discussions in systematic manner during a period of year or two. Then I decide that whole tooling is kinda immature and strange and broken and forgotten. But I learn that Rebol is like a lisp with different syntax. Hmm, lisp you say?

                                                                                    So I learn lisp. I even write my own interpreter in D language. I really like metacircular evaluators and macros and all kind of strange stuff you can get with lisp. I read about Genera and other live environments, which leads me to Smalltalk.

                                                                                    Smalltalk! This seems fine. And I really like the environment. So I order a bunch of books about Smalltalk and start using Pharo. But after a year or so, I realize that class based programming is really not the best solution for my problem.

                                                                                    In 2015/9, I find Self. So I order a PDF manual printed on demand, and I find that it contains a lot of bugs. So I fix them, and order it again. It still contains a lot of bugs, so I fix them again and order another copy. Bonus: I now know Self, because I’ve read a handbook three times in a row. I have a whole personal wiki dedicated to just Self, what I don’t like, what I do, tips and tricks. I read almost all the papers about Self, and all articles (I have a page in wiki just dedicated to articles and I read them one by one), and then whole mail conference.

                                                                                    When I try to write my first programs, I find out that Self is really broken. Unicode doesn’t work, environment is fragile and it is written in C++. I don’t like C++. How hard it would be to rewrite it from scratch? I really don’t want to do that, but how hard would it be to just implement frontend layer and use some existing backend virtual machine, like JVM, or Lua?

                                                                                    One day I read about rpython. So I naturally try to write Self parser in it. And then AST representation. And then compiler. And VM. And suddenly, I am really doing my own reimplementation. And I am writing articles about Self, and about writing your own language, and having this strange conversations with people about structured operating systems and nature of the true object orientation and religious flame wars about languages and their object models.

                                                                                    Suddenly its 2019, my language almost works, and there is this publicly accessible course about GraalVM in the city where I live. So I take some time from work and go there, and the teacher really likes my articles about programming your own language and connects me with some people from Oracle, who worked on the original Self. Sadly, I have no time to push this towards something, because I am trying to bootstrap hybrid of the first version of my wiki in PyQT and tinySelf (thats how I call my little language).

                                                                                    Meanwhile, I still use CherryTree and also notion.so and my distributed wiki is still mostly idea and bunch concept images and pages and mindmaps, more than anything working. But I have dreams. Sometimes they are so vivid, that I am really mad that they are just dreams. And I also still have a lot of frustration from the technology around me.

                                                                                    So I keep working, and shaving the Yak. He doesn’t know it yet, but I am determined to shave him and collapse him back to depth 1. He is restless and kicks around itself and fights me, but I’ll keep shaving it, with the upmost rigor and determination. I will do so, until it is bald and naked. I will conquer all his yakiness, and use it for my own purposes, or die trying.

                                                                                    1. 1

                                                                                      I definitely had a different, less-positive experience reading Daemon. I did not enjoy that book.

                                                                                      1. 1

                                                                                        I guess that depends on the type of the person you are (I was still a teenager back then) and also on time. In 2010, this was really visionary, specifically the idea that you can control physical items via virtual interfaces you see in AR. Of course, there were people who talked about this, but this was the first time I’ve read about it in some consistent and well thought manner. This was before Oculus and google glass and magic leaps, hololens and all kind of this technology we know today.

                                                                                        BTW: I think that most interesting description of the Daemon technology was in the sequel “Freedom”.

                                                                                    1. 9

                                                                                      I love this question!

                                                                                      1. Supposed to be writing a book proposal
                                                                                      2. Why do I need a publisher? Don’t care about the money, just put it online! I need a static site generator.
                                                                                      3. Well, if I write in the R7RS scheme, I can enter it in that little contest that’s going on. I should use Chibi for this
                                                                                      4. I guess I should learn the internals of Chibi, and how to get the most out of it. Wonder if there’s an openbsd feature so I can write an FFI for unveil(2)
                                                                                      5. Better make a PR to add an openbsd feature Done
                                                                                      6. The default scribble docs aren’t what I want. Better go figure out how to hack on Chibi’s Scribble.
                                                                                      7. Oh! There’s a bug in the issue tracker that looks easy to fix dealing with POSIX compat. clearly, I need to spend time understanding how chibi-ffi works to generate stub C code, to fix this bug.
                                                                                      8. Ooohhh, mailing list questions! They are asking about something I haven’t looked into yet, but will surely be important to me, soon.

                                                                                      1. 1

                                                                                        At least you were able to check off something.

                                                                                        1. 1
                                                                                          1. 2

                                                                                            I am well aware of pollen—it’s nice! But, not mine. :)

                                                                                            1. 1

                                                                                              I looked at Pollen and it seems interesting, but the ultimate decision to just write my own was motivated by lack of a community. With Jekyll or Hugo, there are lots of people writing howtos and making their sites open source—if it’s doable at all, there’s usually an example to learn from already. Matthew Butterick and the few third party users I could find all keep the source of their books to themselves, so there’s nowhere to look how they did this or that.

                                                                                              Which is why I’ve added an annotated config and a readme to my own site source right away—there’s no community for it either, but at least there’s on live example to learn from.

                                                                                              1. 1

                                                                                                Matthew Butterick and the few third party users I could find all keep the source of their books to themselves, so there’s nowhere to look how they did this or that.

                                                                                                Maybe they are not easy to find, but some examples are linked at the bottom of this documentation page (16.4 & 16.5), including one of Matthew Butterick’s own books.

                                                                                                1. 1

                                                                                                  Thanks! I would likely have never found it without a pointer.

                                                                                        1. 2

                                                                                          No pictures, no explanation what SLAM is. :(

                                                                                          Different techniques have been proposed but only a few of them are available as implementations to the community.

                                                                                          A problem …

                                                                                          The goal of OpenSLAM.org is to provide a platform for SLAM researchers which gives them the possibility to publish their algorithms.

                                                                                          … that you’re not going to solve? I think they mean “implementations”, not “algorithms”. The algorithms are the bits typically described in the papers.

                                                                                          Nonetheless I tried clicking one of the “Get the Source Code!” links, only to be taken to a 404 on github.

                                                                                          It looks like this site is equivalent to a folder of papers and code. What is this site trying to achieve? What does it mean by “platform”?

                                                                                          From the perspective of existing SLAM researchers:

                                                                                          • Dumping ground for related work?
                                                                                          • Place for discussion?

                                                                                          From the perspective of outsiders (including new SLAM researchers):

                                                                                          • Where do I start? It’s just a list of links.
                                                                                          • Any of the links worthwhile highlighting for beginners?
                                                                                          • What is SLAM?
                                                                                          • What makes this ‘platform’ a good place to submit my implementations?
                                                                                          1. 2

                                                                                            I wish I could’ve tagged this with robotics, which unfortunately isn’t a tag.

                                                                                            SLAM is short for Simultaneous Localisation and Mapping a technique used by robots to determine their location in 2/3D space using the sensors available to them. It’s what a self-driving car would use to determine it’s road position and how to adjust accordingly.

                                                                                            OpenSLAM is a repository of SLAM algorithms (and implementations). If you do find a broken link it would probably help to email the project leads.

                                                                                            1. 1

                                                                                              No pictures, no explanation what SLAM is. :(

                                                                                              I was kinda disappointed that it isn’t opensource version of this SLAM:

                                                                                              1. 1

                                                                                                I’m happy that stuff is proprietary!