Ratfactor

> But no advice that you give about "the correct philosophy" is going to instantly transfer enough knowledge to make all large companies write good code, if only they followed it. Good old "Programming as Theory Building". It's almost impossible to achieve this kind of transfer without already having the requisite lived experience. [0]: https://ratfactor.com/papers/naur1_theory_building.pdf

Thanks! I'm reading Starting Forth[^1] and Forth: The programming language that writes itself[^2] and they're great so far, particularly the latter! I'm a bit self-conscious, now that you've asked, but I suppose I was looking to find resources walking through a Forth program end-to-end; perhaps a tutorial building something Forth is particularly well-suited for. [^1]: https://www.forth.com/starting-forth/ [^2]: https://ratfactor.com/forth/the_programming_language_that_writes_itsel…

The timing of this article is great for me as lately I'm fascinated by the Forth language and the simplicity behind its apparent strangeness. I've been tempted to start playing with similar ideas just for fun. (https://ratfactor.com/forth/the_programming_language_that_writes_itsel… is a great read, btw.)

http://ratfactor.com/ Content is statically generated from an AsciiDoc text file wiki managed by a Vim plugin. Though I write heavy Web applications for a living, there's no JS on my personal website except on specific pages with interactive tools. After a revamp a couple years ago, all dynamic server-side actions are handled with old-school CGI applications. Retro and loving it. I'm really enjoying looking at everyone else's sites!

user8 and ratfactor should have a coffee (or tea) together and chit-chat https://ratfactor.com/ascetic-computing

Yeah, sam is not universal, but it can solve complex tasks more simply by just running it a few times. The final example already normalizes \n (v/./ c/\n/) in a single pass, but we can make it even simpler by just writing: , x/(.+\n)+/ .,+#0-#1 x/\n/ c/ / , x/\n+/ c/\n/ (I haven’t tested it.) I’m glad that sam worked out for you. You can learn more from [1] and [2]. If you need any help, you’re always welcome to ask me. [1]: https://ratfactor.com/papers/sam_tut.pdf [2]: https://9p.io/sources/contrib/steve/other-docs/struct-regex.pdf

It's a pithy philosophy if you already know what it means to "work". You probably don't, especially if your system is human facing. Figuring out what "works" means is almost as difficult as building things in the first place. You may as well commit to building it twice [0]. [0] https://ratfactor.com/cards/build-it-twice

Usually more about the technology behind it than about the site itself. eg: I consider this a colophon https://world-playground-deceit.net/about/website.html ...and this recent link through n.y.c came through when I searched as having a "Colophon" for the project: https://ratfactor.com/snobol/ ...the wiki link talks a little bit about "website colophons" as well.

Upvote for Ratfactor who made the most useful HTMX reference around (even though it wasn't completed) https://ratfactor.com/htmx/

On point 4, I don't use zig but a two second google leads to http://ratfactor.com/zig/stdlib-browseable2/math/atan.zig.html I wonder about the accuracy of the rest of the article.

This is probably the closest to what I'm remembering: https://ratfactor.com/repos/reporat/ — but it's still not quite it.

For people interested in Forth I think this is a nice intro: https://ratfactor.com/forth/the_programming_language_that_writes_itsel…

That isn't syntax. : is a word, and so is ; Cool article posted to HN a little while back: http://ratfactor.com/forth/the_programming_language_that_writes_itself…

Wikipedia [0] via Dave Gauer's Forth webpage on Ratfactor.com [1] [0] https://en.wikipedia.org/wiki/ColorForth [1] https://ratfactor.com/forth/the_programming_language_that_writes_itsel…

I saw a blog post a few days ago about this a few days ago, http://ratfactor.com/leaving-github Which might have been you or someone with a similar sentiment. Anyway Github's 2FA does not require a phone or SMS. I do not use a phone or SMS for Github 2FA myself, or for most sites. Might be unrelated - I also notice the blog post tries to clarify that it isn't about phone numbers, but they fail to clarify what it's actually about, and aren't interested in other methods... which is confusing.

See also: * How the GNU coreutils are tested: https://www.pixelbeat.org/docs/coreutils-testing.html * Exploration of each of the coreutils commands: https://ratfactor.com/slackware/pkgblog/coreutils * Command line text processing with GNU Coreutils: https://learnbyexample.github.io/cli_text_processing_coreutils/ (my ebook that covers 20+ text processing tools)

I think you should be able to read a 9 page paper. But here is a summary: https://ratfactor.com/papers/naur1.

Tangent: I remember reading this in its original presentation-prototype form, which is basically this article with much less text and more plotholes. The reason I'm mentioning it is because it's also a beauty of minimalism in terms of underlying website technology. [0] http://ratfactor.com/forth/forth_talk_2023.html [1] http://ratfactor.com/minslides/

Sounds like Steve Yegge's wheelhouse. Possibly this post https://gist.github.com/cornchz/3313150 but there are plenty more https://ratfactor.com/yeggedex

Yes, 11 lines of debugged, delivered source lines of code written per day is within the normal range. The basic COCOMO model used by David A. Wheeler's "SLOCCount" estimates person-months as 2.4 * (KSLOC**1.05), which was calibrated with painfully-won experience on a variety of software projects in the 80s. If you approximate that as 2.4 months per kSLOC, it works out to 13.7 lines of code per calendar day, or 18.5 lines of code per workday. Other studies found lower speeds. Like 10: https://softwareengineering.stackexchange.com/questions/450695/where-d… Every programmer thinks this is stupid the first time they see it, because we can all remember times we wrote 50 or 100 or 200 or 300 lines of code in a day, and that code worked. But other days we write zero lines of code, because we spend them in meetings, or debugging code, or arguing about the protocol design, or testing hardware we need to support, or testing our code. And sometimes we'll spend a week refactoring the codebase to reduce the number of lines of code (https://www.folklore.org/Negative_2000_Lines_Of_Code.html) so those 200 or 300 lines of code may not end up in the delivered product—if they were ever intended to, since test stubs and test scripts also don't count as delivered code. And that's how we get to Peter Naur's "Programming as Theory Building": https://ratfactor.com/papers/naur1 because writing the code clearly isn't the…

MNT Pocket Reform https://ratfactor.com/mnt-pocket-reform/

Ftfy: http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.… https://www.parsonsmatt.org/2017/10/11/type_safety_back_and_forth.html https://lwn.net/Articles/336262/ https://tomasp.net/blog/2015/library-frameworks/ https://ratfactor.com/cards/not-quite-the-same https://matklad.github.io/2023/11/15/push-ifs-up-and-fors-down.html

I have a similar list I like to share, had a few from Carl's list, will probably add a few from it. http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.… https://www.parsonsmatt.org/2017/10/11/type_safety_back_and_forth.html https://lwn.net/Articles/336262/ https://tomasp.net/blog/2015/library-frameworks/ https://ratfactor.com/cards/not-quite-the-same https://matklad.github.io/2023/11/15/push-ifs-up-and-fors-down.html