jonesforth
pytudes
jonesforth | pytudes | |
---|---|---|
41 | 100 | |
968 | 22,397 | |
- | - | |
0.0 | 8.3 | |
about 1 year ago | 16 days ago | |
Assembly | Jupyter Notebook | |
- | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
jonesforth
- Konilo: A personal computing system in Forth
-
Thinking Forth: A Language and Philosophy for Solving Problems [pdf]
Cool. Here are some other resources that I've encountered along the way of learning Forth:
- JonesForth: https://github.com/nornagon/jonesforth/blob/master/jonesfort...
This is legit a text that goes the an x86 Forth implementation. Actually, it's just an implementation with really extensive comments. That said, including whitespace and comments, it's just 2000 lines and the pedagogy is excellent. Highly recommended for anyone who would rather see behind the curtain before picking up a larger text.
- SmithForth: https://dacvs.neocities.org/SF/
So, Smith decided to hand-write a Forth directly in x86-64 opcodes (well, the corresponding ascii hex bytes). It's incredibly slim and enlightening how you can bootstrap a language in just a couple hundred bytes or so.
This project actually inspired me to really learn the x86-64 architecture, so I ended up hand-decompiling the SmithForth binary instead of going through his commented implementation. Hand-decompilation is an absolutely fascinating exercise. You learn all about ELF structure, opcode encodings, and actually start to see the gaps where microarchitectural details shine through. Highly recommended for any hacker that really wants to grok low level details.
- Mecrisp: https://mecrisp.sourceforge.net/
An amazingly fast Forth implementation for MSP430, ARM, RISC-V, MIPS, and some FPGAs. This gave me one really nice understanding of Forth as
A REPL into your hardware!
-
Problem Running JonesFORTH
I've git-cloned JonesFORTH (https://github.com/nornagon/jonesforth/blob/master/jonesforth.S) and achieved to compile it (i.e. run make w/o an error. When I start the executable, it presents me with an empty line, and when I say BYE, it says PARSE ERROR: bye.
-
Ask HN: Where do I find good code to read?
Is there any particular language you're looking for? I've found some languages hideous until I understood them and could appreciate their respective graces. Off the top of my head the I can think of a couple.
The first is Jones Forth (https://github.com/nornagon/jonesforth), start with jonesforth.S and move into jonesforth.f. I really enjoyed following along with it and trying my hand at making my own stack based language.
The other is Xv6, a teaching operating system from MIT (https://pdos.csail.mit.edu/6.828/2021/xv6.html), not all the code or implementations are top notch but it shows you non-optimized versions (just because they're simple and more readable) of different concepts used in OS design.
If you're interested in the embedded world, there is a really neat project I've been following that feels a more structured and safe (as in fault-tolerant) while still staying pretty simple (both conceptually and in the code itself): Hubris and Humility (https://hubris.oxide.computer/).
-
Dusk OS: 32-bit Forth OS. Useful during first stage of civilizational collapse
Very low hardware requirements, so basic industrial control at the level where you'd otherwise use an Arduino or so but on scavenged hardware. Forth is ridiculously simple to get an implementation running.
https://github.com/nornagon/jonesforth/blob/master/jonesfort...
Is a nice starting point. It's obviously not as compact as say 'Brainfuck' but it is far more versatile.
-
Making my own forth implementation
OP mentioned jonesforth, but linked to a nasm port of it. Which is probably good it’s just that the documentation in the comments with ascii art doesn’t look right on my screen. So here’s a more common repo: https://github.com/nornagon/jonesforth
-
Struggling with looping constructs, BEGIN WHILE REPEAT
Rip the asm macros for the basic FORTH words out of this and then embed them in a C binary, statically linked with your favourite libs for whatever task. Although I haven't tried this yet, I'm planning on doing it with ncurses for my own Roguelike. From there, if you can convert the function calls and your parameters down to raw numbers, you can send instructions to ncurses or whatever other API you like, directly from a FORTH stack.
- I'm wondering why so few forth microcontoller tutorials are out there?
-
replace jonesforth links to the left by proper link
or the mirror of this site in github: https://github.com/nornagon/jonesforth
- Languages to implement in space-constrained environments
pytudes
-
Ask HN: High quality Python scripts or small libraries to learn from
Peter Norvig's work is great to learn from https://github.com/norvig/pytudes
- Norvig's 2023 Advent of Code
- Ask HN: How to build mastery in Python?
- SQL for Data Scientists in 100 Queries
- Bicycling Statistics
-
Ask HN: How to deal with the short vs. long function argument
I've been a programmer for 25 years. A realization that has crept up on me in the last 5 is that not everyone thinks that functions should be short: there are two cultures, with substantial numbers of excellent programmers belonging to both. My question is: how do we maintain harmonious, happy, and productive teams when people can disagree strongly about this issue?
The short-functions camp holds that functions should be short, tend toward the declarative, and use abstraction/implementation-hiding to increase readability (i.e. separable subsections of the function body should often be broken out into well-named helper functions). As an example, look at Peter Norvig's beautiful https://github.com/norvig/pytudes. For a long time I thought that this was how all "good programmers" thought code should be written. Personally, I spent over a decade writing in a dynamic and untyped language, and the only way that I and my colleagues could make that stuff reliable was to write code adhering to the tenets of the short-function camp.
The long-functions camp is, admittedly, alien to me, but I'll try to play devil's advocate and describe it as I think its advocates would. It holds that lots of helper functions are artificial, and actually make it _harder_ to read and understand the code. They say that they like "having lots of context", i.e. seeing all the implementation in one long procedural flow, even though the local variables fall into non-interacting subsets that don't need to be in the same scope. They hold that helper functions destroy the linear flow of the logic, and that they should typically not be created unless there are multiple call sites.
The short-function camp also claims an advantage regarding testability.
Obviously languages play a major role in this debate: e.g. as mentioned above, untyped dynamic languages encourage short functions, and languages where static compilation makes strong guarantees regarding semantics at least make the long-function position more defensible. Expression-oriented and FP-influenced languages encourage short functions. But it's not obvious, e.g. Rust could go both ways based on the criteria just mentioned.
Anyway, more qualified people could and have written at much greater length about the topic. The questions I propose for discussion include
- Is it "just a matter of taste", or is this actually a more serious matter where there is often an objective reason for discouraging the practices of one or other camp?
- How can members of the different camps get along harmoniously in the same team and the same codebase?
-
Pytudes
I have the same impression. Reading the code, he uses global variables [1], obscure variable (k, bw, fw, x) and module names ("pal.py" instead of "palindromes.py"), doesn’t respect conventions about naming in general (uppercase arguments [2], which even the GitHub syntax highlighter is confused about). This feels like code you write for yourself to play with Python and don’t plan to read later.
Some parts of the code feel like what I would expect from a junior dev who started learning the language a couple weeks ago.
[1]: https://github.com/norvig/pytudes/blob/952675ffc70f3632e70a7...
[2]: https://github.com/norvig/pytudes/blob/952675ffc70f3632e70a7...
- Ask HN: Where do I find good code to read?
-
Using Prolog in Windows NT Network Configuration (1996)
Prolog is excellent for bikeshedding, in fact that might be its strongest axis. It starts with everything you get in a normal language such as naming things, indentation, functional purity vs side effects, where to break code into different files and builds on that with having your names try to make sense in declarative, relational, logical and imperative contexts, having your predicates (functions) usable in all modes - and then performant in all modes - having your code be deterministic, and then deterministic in all modes. Being 50 years old there are five decades of learning "idiomatic Prolog" ideas to choose from, and five decades of footguns pointing at your two feet; it has tabling, label(l)ing, SLD and SLG resolution to choose from. Built in constraint solvers are excellent at tempting you into thinking your problem will be well solved by the constraint solvers (it won't be, you idiot, why did you think that was a constraint problem?), two different kinds of arithmetic - one which works but is bad and one which mostly works on integers but clashes with the Prolog solver - and enough metaprogramming that you can build castles in the sky which are very hard to debug instead of real castles. But wait, there's more! Declarative context grammars let you add the fun of left-recursive parsing problems to all your tasks, while attributed variables allow the Prolog engine to break your code behind the scenes in new and interesting ways, plenty of special syntax not to be sneezed at (-->; [_|[]] {}\[]>>() \X^+() =.. #<==> atchoo (bless you)), a delightful deep-rooted schism between text as linked lists of character codes or text as linked lists of character atoms, and always the ISO-Standard-Sword of Damocles hanging over your head as you look at the vast array of slightly-incompatible implementations with no widely accepted CPython-like-dominant-default.
Somewhere hiding in there is a language with enough flexibility and metaprogramming to let your meat brain stretch as far as you want, enough cyborg attachments to augment you beyond plain human, enough spells and rituals to conjour tentacled seamonsters with excellent logic ability from the cold Atlantic deeps to intimidate your problem into submission.
Which you, dear programmer, can learn to wield up to the advanced level of a toddler in a machine shop in a mere couple of handfuls of long years! Expertise may take a few lifetimes longer - in the meantime have you noticed your code isn't pure, doesn't work in all modes, isn't performant in several modes, isn't using the preferred idiom style, is non-deterministic, can't be used to generate as well as test, falls into a left-recursive endless search after the first result, isn't compatible with other Prolog Systems, and your predicates are poorly named and you use the builtin database which is temptingly convenient but absolutely verboten? Plenty for you to be getting on with, back to the drawing boar...bikeshed with you.
And, cut! No, don't cut; OK, green cuts but not red cuts and I hope you aren't colourblind. Next up, coroutines, freeze, PEngines, and the second 90%.
Visit https://www.metalevel.at/prolog and marvel as a master deftly disecting problems, in the same way you marvel at Peter Norvig's Pytudes https://github.com/norvig/pytudes , and sob as the wonders turn to clay in your ordinary hands. Luckily it has a squeaky little brute force searcher, dutifully headbutting every wall as it explores all the corners of your problem on its eventual way to an answer, which you can always rely on. And with that it's almost like any other high level mostly-interpreted dynamic programming / scripting language.
What are some alternatives?
stoneknifeforth - a tiny self-hosted Forth implementation
paip-lisp - Lisp code for the textbook "Paradigms of Artificial Intelligence Programming"
factor - Factor programming language
asgi-correlation-id - Request ID propagation for ASGI apps
durexforth - Modern C64 Forth
clerk - ⚡️ Moldable Live Programming for Clojure
tinyrenderer - A brief computer graphics / rendering course
nbmake - 📝 Pytest plugin for testing notebooks
sectorforth - sectorforth is a 16-bit x86 Forth that fits in a 512-byte boot sector.
PySimpleGUI - Python GUIs for Humans! PySimpleGUI is the top-rated Python application development environment. Launched in 2018 and actively developed, maintained, and supported in 2024. Transforms tkinter, Qt, WxPython, and Remi into a simple, intuitive, and fun experience for both hobbyists and expert users.
SavjeeCoin - A simple blockchain in Javascript. For educational purposes only.
project-based-learning - Curated list of project-based tutorials