5 ms·
One of the reasons is that the Red community is very small and entrenched. They know everything that comes out of the language, and to them everything is easy a
by dmitriid 8y ago
One of the reasons is that the Red community is very small and entrenched. They know everything that comes out of the language, and to them everything is easy and understandable.
They will fight you to the death if you even try to say that "english-like syntax with no parantheses" is the opposite of readable or understandable when you don't know the system.
Go into any of Red's source files and you will end up looking at dozens to hundreds of lines of code with no comments and which often look like this:
return old-gradient-pen DC cmds start tail cmd sym catch?
OS-draw-brush-pattern DC size crop-1 crop-2 word as red-block! cmd sym = fill-pen
_read opfd hash alg-digest-size type
etc. These are obviously impossible to look up and find.
The whole development is haphazard as well. Everything hinges on two may be three people who know Red internals wihch frantically move from subsystem to subsystem developing features and patching wholes.
Patching wholes are usually like this:
- issue is raised on GitHub
- it's acknowledge
- a fix is written (with zero comments even for the complex issues) and merged
- the issue is closed with a "tested" label [1]
About 0.001% of "tested" issues contain any tests. The majority of fixes are apparently only fixed and manually tested against the reported issue.
etc. etc.
https://github.com/red/red/issues?q=is%3Aissue+is%3Aclosed+label%3Astatus.tested https://github.com/red/red/issues?q=is%3Aissue+is%3Aclosed+l...
- 9214 8y agoI don't recall anyone fighting to the death over someones syntactic preferences. Code written by experienced users (and Red codebase in particular) is a hard nut to crack, that's true. Regarding development: I'd appreciate if you elaborate over your critique. Concrete suggestions on how development and testing processes can be improved are always welcomed.
- dmitriid 8y ago> Regarding development: I'd appreciate if you elaborate over your critique. There's nothing to elaborate, really. If you list all "status.tested" issues, how many are tested? Let's take the top few as of today. 1. Malignant output from react/link, https://github.com/red/red/issues/3713 https://github.com/red/red/issues/3713 fix: https://github.com/red/red/commit/644be4b1e3bfcf70a5f9f5e0066fdd2cc964cd73 https://github.com/red/red/commit/644be4b1e3bfcf70a5f9f5e006... One-line fix, sure. Where's the test? 2. new-line flags are not cleared on subsequent calls, https://github.com/red/red/issues/3707 https://github.com/red/red/issues/3707 Fix: https://github.com/red/red/commit/b7ee2846b58a1328d57002b3ed2d076d65ca4b7e https://github.com/red/red/commit/b7ee2846b58a1328d57002b3ed... Severl line-fix. Where's the test? 3. stack overflow on limited append/insert, https://github.com/red/red/issues/3705 https://github.com/red/red/issues/3705 The fix contains a single test even though the issue provided three different failure modes: https://github.com/red/red/commit/bd41d35ee5a73cd5779647b50376b0d757c9e8a0 https://github.com/red/red/commit/bd41d35ee5a73cd5779647b503... And so on and so forth. I remember seeing a "status.tested" which added easily a hundred lines of new code with zero tests. Funnily enough I see you've added a "test.written" label, which really shouldn't be there because that's what "status.tested" is for. ---- But forget issues and tests for the moment. Out of 44 contributors to Red, only two have anything significant to contribute: the people who actually develop Red. Of all the issues reported almost none contain code to fix the issue. Almost all issues are fixed by the same two people who develop Red. Perhaps it's due to the fact that about zero percent of Red code is documented? Or that "Code written by experienced users (and Red codebase in particular) is a hard nut to crack"? Which is kinda ironic, considering how the authors and proponents gush about Red's simplicity. Go back to the first issue in the list above. It's a one-line fix. So, surely, it could be fixed by someone else but the author of the language? Too bad the file where the issue is fixed is this: https://github.com/red/red/blob/644be4b1e3bfcf70a5f9f5e0066fdd2cc964cd73/environment/reactivity.red https://github.com/red/red/blob/644be4b1e3bfcf70a5f9f5e0066f... 336 lines of no significant comments other than trivia for the author himself. "New line flags not cleared" whose fix is just a few lines? Oh, it's in a 3000-line file with no comments, https://github.com/red/red/blob/b7ee2846b58a1328d57002b3ed2d076d65ca4b7e/runtime/natives.reds https://github.com/red/red/blob/b7ee2846b58a1328d57002b3ed2d... And so on and so forth. And since very very few of those lines are covered by any tests (even for issues reported and fixed), how is anyone except the two authors can ever fix those issues or contribute? If "Code written by experienced users (and Red codebase in particular) is a hard nut to crack", how can you expect people to believe in it's "simplicity and fun"? ----
- dmitriid 8y agoAs a separate comment. Let's consider Elixir, for example. Issue: EEx multiple callbacks with `-> %>…<% end` format, https://github.com/elixir-lang/elixir/issues/8590 https://github.com/elixir-lang/elixir/issues/8590 Fix: https://github.com/LostKobrakai/elixir/commit/d33fdb57d457dd8bd845f05389e7bc7096cae3f6 https://github.com/LostKobrakai/elixir/commit/d33fdb57d457dd... It describes what the code does in a comment, there are tests. The file itself contains comments crucial to understanding: https://github.com/LostKobrakai/elixir/blob/d33fdb57d457dd8bd845f05389e7bc7096cae3f6/lib/eex/lib/eex/tokenizer.ex https://github.com/LostKobrakai/elixir/blob/d33fdb57d457dd8b... Compare this to any Red issue, fix, or any source file in the codebase
- 9214 8y agoBus factor - fair enough. Lack of tests - have you counted them? [1] 2/3 of issues you showed are purely formatting concerns, so I'm not sure what needs to be tested there. "test.written" refers to test being written in a testing framework, "status.tested" means that the described bug was tested in multiple development environments and confirmed. So your remark is slightly off the base. Small number of dedicated contributors: historically, Rebol (the ancestor of Red) was developed by Rebol Tech company in a closed manner. So, IMO there developed a particular community mindset, where everyone just lets the Boss do the job and watches the action from the tribunes. Another reason, like I said elsewhere, is the fact that Rebol never became mainstream, hence there isn't much contributors ready to provide the code of acceptable quality. Lack of comments and such: in the early days, Red planned to be minimal and bootstrapped early, so the whole codebase was written in a throw-away fashion, with no comments or afterthoughts. As the project growed and roadmap changed its curves, community started raising demands (macOS View backend, new datatypes, supporting other platforms, the list goes on), so the "quick bootsrap" plan was ditched, but the code remained. This is a stumble block for other contributors, which, alas, will be moved away only after 1.0 is reached. "Simplicity and fun" is completely off the point though, but I get what you say, even with a snarky tone. "Simplicity" here refers to the use of embedded DSLs, in which it is generally easy to express ideas suitable for a particular domain, and to "self-contained small toolchain" goal of the project. So, expressing ideas and developing them is rather simple, once you got the hang of the language. Reading Red code requires a prior knowledge of function's arity and evaluation rules; ambitious projects require knowledge of multiple dialects and thorough understanding of core concepts; dynamic pieces (i.e. metaprogramming) can be challenging, unless you're coming from Lisp or Forth camp. Runtime is written in Red/System dialect, which requires C-level skills to write. Red and Red/System share the same syntax, but require a huge mental leap to switch the context (Lisp vs. C dichotomy) - another 2 cents to your "lack of contributors". I'm not a fan of "Red is simple and for everyone" sales pitch either - it's misleading at best, sets the wrong expectations and usually comes from people who barely clocked 1 hour in REPL tinkering with available View examples. Hope that answers your concerns, more or less. If you want to alleviate them more quickly - drop by our community chat and start contributing piece by piece ;) Cheers. [1]: https://github.com/red/red/tree/master/tests https://github.com/red/red/tree/master/tests
- greggirwin 8y agoDevelopment is far from haphazard, but we're always open to examples of how other projects we can learn from, as long as it's a fair comparison and the resource and organization aspects align enough that we can leverage things we learn.
- dockimbel 8y agoNot liking Red is understandable. Programming languages, as largely subjective HCI, cannot appeal to every single software developer. Though, that is not a reason to be dishonest, and trying to paint a bad picture of our work (even in fallacious ways, as demonstrated below). > One of the reasons is that the Red community is very small and entrenched. "Entrenched" is just your opinion, not a fact. Given the rest of your post(s), your opinions about the Red project are demonstrably uninformed and highly subjective. > They know everything that comes out of the language, and to them everything is easy and understandable. If the core Red team and main contributors didn't "know everything that comes out of the language, and to them everything is easy and understandable.", that would be very worrying, don't you think so? > They will fight you to the death if you even try to say that "english-like syntax with no parantheses" is the opposite of readable or understandable when you don't know the system. Exaggerated, like your whole post. We have civil discussions with people who are actually interested in discussing about Rebol and Red. [1] From the way you sound, I am wondering if you might be one of the few arrogant people who show up on our online channels from time to time, trying to lecture us about "their right way" using a condescending tone...usually, that does not end well. Fortunately, such bad encounters are rare. We often get lispers showing up from CL, Scheme, or even language authors, like Joe Armstrong (Erlang's author) on our Gitter chats in 2017 IIRC, who liked Red and labelled it a "fun" language. Though, Joe was later upset by our branching into the blockchain world, like a few others in the community, but I hope they see now that we did it for good reasons. > Go into any of Red's source files and you will end up looking at dozens to hundreds of lines of code with no comments and which often look like this: return old-gradient-pen DC cmds start tail cmd sym catch? OS-draw-brush-pattern DC size crop-1 crop-2 word as red-block! cmd sym = fill-pen _read opfd hash alg-digest-size type Patching together cherry-picked lines of code from different Red/System files, with zero context...how dishonest. (I give a detailed context and explanation about those lines you have extracted from different sources on a separate page [8], as it is quite long. It also debunks your "no comments" claim as the first line you have picked has 3 comments in the neighbouring lines.) So, you went to cherry-pick low-level code parts in Red/System, involving OS API calls, for what? For making a preposterous statement like "These are obviously impossible to look up and find."?... Those lines of code are not mine, though it took me only a few of seconds using a basic code editor (not even pulling VSCode with the Red plugin) to fetch the information needed to fully understand those expressions...so much for the "obviously impossible to look up and find"... People are using free-ranging evaluation in Red and Rebol code since 20 years, and readability is not something users complain about (they were certainly many other issues to complain about, but that is not one). On the contrary, it is one of the Rebol features I have found the most attractive, as have many others. I can understand that your mind is not wired for that, and that you don't like it, but that's not a reason for getting angry at us, nor at Red. The sad part is that you don't even bother asking why such design choice was done in the first place, and what is the aimed trade-off behind it...that speaks volume about your real agenda here. > The whole development is haphazard as well. Great, another armchair expert on Red! You are obviously not a Red contributor, I doubt you are a Red user either, so you really have no clue about the project's history, nor goals, nor organization, nor its real-world constraints (at this point, I don't think you care at all anyway, you are just here for bashing). Funny how you jumped from a feature of the language syntax to development process. Your post is really not meant to inform anyone, but only to cast negativity over the Red project...for no good reason. > Everything hinges on two may be three people who know Red internals wihch frantically move from subsystem to subsystem developing features and patching wholes. Let me rephrase that properly for you: "The core Red team is working very hard, despite being small, on many different sub-systems, restlessly implementing new features and fixing issues, making the Red users and community happier every day!". So now being a small, but very capable team is something bad? As you praise a pretty much solo-project later, I don't get the rationale there...double standard I guess. Moreover, you don't even know what you are talking about (again). I can count at least 7 people in the Red community, including the core team, capable of working on the Red internals, adding features or fixing bugs. Maybe it has escaped your understanding, but we are building a stack of programming languages (with lot of system programming), and not a web site. The skills and experience required for properly doing such work are very rare. The few capable people also have real-life constraints, so the permanent core team capable on working on the internals is currently 3 people, with additional 2 or 3 more working on their spare time. We are lucky and grateful to have that many capable people with us already. We are still in the early days, with an alpha Red, so having a small compact team is rather an advantage, as there is still significant design to do. > a fix is written (with zero comments even for the complex issues) and merged From 10 days ago, ticket #3692 [2] referenced a hard to reproduce complex crash (an heiseinbug), and includes a few hundred lines of detailed explanations about the debugging process, including some screenshots. I usually only comment some fixes when the explanation or fix is not obvious for the team. Sometimes, the comment is just put in the commit log. Systematically commenting all fixes would be useless anyway, as many fixes are straighforward, or simply don't deserve any comment (like the "Malignant output from react/link" [3] one you've pointed out below). Moreover, we have a strong presence on our Gitter chat, and are always happy to help contributors ramp up when needed. If someone thinks that a particular fix requires a comment or explanation, we are always glad to provide it. > About 0.001% of "tested" issues contain any tests. The majority of fixes are apparently only fixed and manually tested against the reported issue. You are implying here that tests for bugfixes are non-existent. Let's put your extravagant claims to the test (pun intended): - 1076 tickets with `status.tested` and `type.bug` tags [4] - 52 tickets with the extra `test.written` tag [5] That gives a 4.83% result...so about 5000 times more than your claim! That's what happens when you are pulling fake numbers out of your ass. Moreover, as you are wilfully ignorant about Red project (confirmed by your other posts), you don't know that: * the tests are sometimes provided in a later commit (using a `TEST:` prefix in the log), not necessarily within the fix commit. * some tickets get a test written, but the `test.written` tag is not set (no stats there, not sure how many) * we do try to address in batches the missing regression tests for fixes, from time to time. The last point has led to the creation of a specific test file [6] that gathers tests written in those batch sessions. I count 242 more tests there, so it gives a total of 294 written tests for fixes, about 27.3% as the final result. So much for the "0.001%"... That result is surely not satisfying though, even if 100% is not a goal there, as explained above, we should get a much more complete coverage for bugfixes. > etc. etc. Typical ending for a FUD-spreading post... The only honest statement from you I can find is your Twitter account's baseline [7]: "Opinions on things I know nothing about". That sums up well your posts here about Red. [1] http://lambda-the-ultimate.org/node/1240#comment-48582 http://lambda-the-ultimate.org/node/1240#comment-48582 [2] https://github.com/red/red/issues/3692 https://github.com/red/red/issues/3692 [3] https://github.com/red/red/issues/3713 https://github.com/red/red/issues/3713 [4] https://github.com/red/red/issues?q=is%3Aissue+is%3Aclosed+label%3Astatus.tested+label%3Atype.bug https://github.com/red/red/issues?q=is%3Aissue+is%3Aclosed+l... [5] https://github.com/red/red/issues?q=is%3Aissue+is%3Aclosed+label%3Astatus.tested+label%3Atype.bug+label%3Atest.written https://github.com/red/red/issues?q=is%3Aissue+is%3Aclosed+l... [6] https://github.com/red/red/blob/master/tests/source/units/regression-test-red.red https://github.com/red/red/blob/master/tests/source/units/re... [7] https://twitter.com/dmitriid https://twitter.com/dmitriid [8] https://pastebin.com/jezLyDVt https://pastebin.com/jezLyDVt
- dockimbel 8y agoHere are a some facts about Red to debunk your attempt at spreading false information, like the "no tests" and "no comments". For the record, we have written a large number of unit tests (in addition to the regression tests mentioned above) since the beginning: * 22196 tests for Red (with ~10k of them running once for the compiler, once for the interpreter) * 9847 tests for Red/System Without this large test suite, the development of Red would simply be impossible. Though, the features coverage is still not exhaustive, as we are still lacking tools for measuring it (contributions welcome!). Now for the supposedly total absence of comments, here are some stats from red/red repo extracted using a simple Red script [1]: -- Type -- FileCount -- LOC -- Comments -- Cmts/LOC (rounded to nearest integer) .r 39 25186 3507 14% .red 48 16495 776 5% .reds 154 85742 7687 9% Basically, .r represents our toolchain code in Rebol, while all the runtime and standard library are in .red and .reds (Red and Red/System respectively). Those ratios are not bad, but could be better (10-15% in each category would be a good goal). More comments could be still added in some complex code sections, though embedding a full documentation of the code, in the code, is not our approach (see more explanations below). As an extra note, I have noticed a pattern with wannabee contributors with no system programming skills, of thinking that heavy commenting in the runtime low-level code would magically make them become system programmers... The plan has always been to provide architecture-oriented documents and code maps to ease the navigation for core contributors. Though, the core team does not have the resources for now to do that, as our short/mid-term roadmap is already overloaded. Some of our contributors have documented some parts, but those docs are scattered around, and in multiple languages, not necessarily in English. I am also taking this opportunity to address those points from a higher perspective. Given: * the unusually large spectrum of the project for a programming language (stack of multiple languages, very rich standard library, cross-platform, self-contained,...), * the bootstrapping process that would lead us to the aimed selfhosted Red in 2.0, * the funding needs to sustain the project both in short/mid/long-terms, * our business goals (in addition to the purely technical ones), * expectations of low number of contributors until 1.0 (due to some unique aspects of our stack), we have strived to find ways to go as fast as possible through the bootstrapping phase. So since the beginning, we have taken shortcuts, to implement the features needed for 1.0 as quickly as possible. That means less comments in the code (as the team is small and work at the same location), postponing the writing of many regression tests, postponing some design decisions and some edge cases processing, writing only minimal survival docs for the team and close contributors. So, FYI, there is a "catch-up" stage planned between 0.9 and 1.0, where we will address those gaps, as we want a rock-solid and properly documented, 1.0. Moreover, when all design decisions are not set in stone, systematically testing/documenting all the features or code parts that may be dropped later is not winning move. In practice, regressions are rare in Red codebase, so the missing regression tests are not a show-stopper either, and we can live with that until 0.9. [1] https://gist.github.com/dockimbel/2af078e02e56fcc092aea771de0c5e9a https://gist.github.com/dockimbel/2af078e02e56fcc092aea771de...