assembly
textual
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.
assembly
-
Should you add screenshots to documentation?
When you're learning something for the first time, it can be hard to know what mental model you need to have to be effective with the tool.
Some documentation is reference material. With reference material you might navigate the reference material in a particular traversal to get what you need to do what you want.
But at the beginning of your journey, you need to be taught a "flow" an expected pattern of operation to build up the right mental model of how an average session with the tool works. For programming this might be the edit file, compile, run, debug loop, or TDD or IntelliJ's build and deploy. Or a CI system commit, push, deploy, promote cycle. Or kubernetes kubectl edit, apply.
I opened the "dining philosophers TLA+" example and ran it - this seemed to be an affordance of the TLA+ Toolbox GUI which was straightforward to understand.
But then I tried to use the tool with my own. I interpreted the existing code of the dining philosophers and tried to make my own ringbuffer model.
It took me a while that I needed to update this screen to put in the following details that I have filled in on the screenshot:
https://github.com/samsquire/assembly/blob/main/screenshots/...
You have to put your entrypoint in the "temporal formula" and then put your model arguments on the right hand side.
I was able to piece together the operation of this tool by piecing together various reference details together, it wasn't until I saw that screenshot I referenced in my OP that I realised I needed to do that step to get the PlusCal code to update the TLC code that follows it. I was wondering why it didn't work until I saw that screenshot.
-
Fiber in C++: Understanding the Basics
Thank you for this in-depth article.
I am a less than a C++ beginner but I asked Stack Overflow how to run C++ coroutines in a thread pool. It seems coroutines in C++20 are unfinalised but don't quote me on that but I did get some sourcecode for older versions of the C++20 standard.
I used Marce's Col's excellent blog post about how to create coroutines in assembly by adjusting the RSP pointer.
https://blog.dziban.net/posts/coroutines/
I extended Marce's code to run the coroutines in kernel threads:
https://github.com/samsquire/assembly (see threadedcoroutines.S)
I have been thinking of coroutines in terms of query compilation for database engines and the volcano query model and this article:
https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
Tying together two pieces of code that call eachother in push or pull driven style is really powerful. Or if you're running multiple independent tasks that need their own state. This as I understand it is the original intent of object orientation that Alan Kay wanted and is represented by Erlang and partly Go.
Specifically, I am thinking of compiler created coroutines where code can be interleaved at compile time rather than at runtime.
-
Philosophy of Coroutines
Thank you for your ideas and thoughts.
This might be relevant - I've been playing around with some assembly to unwind the stack, but it occurred to me I don't need to pop the stack to scan through it. So like C++ exception handling (I learned about it in the Itanium C++ ABI) or algebraic effects, you can scan memory if you have access to the stack start in memory (I do that by storing the rsp somewhere in .global main) in theory it's just data.
I need to generate sections of lookup data for range information for associating .text code section addresses with function names.
In theory this would also be useful for coroutines since a coroutine position/state is just a program counter position of code that you can JMP to in your yield function (that isn't a call but an offset)
To move a coroutine from one thread to another or another machine over the network or persist to disk, let me think. We could do what C++ coroutines does and have a promise struct object that is presumably on the stack when a coroutine resumes by jumping to that coroutines location.
I think the hard part is being stackless and persisting the current coroutine state. You could mov $COMPILER_DETERMINED_OFFSET into -10(%rbp) that promise object and then when the coroutine resumes it does a JMP -10(%rbp) in a label before the coroutine body.
I am a beginner to assembly programming but here is my program: https://github.com/samsquire/assembly/blob/main/stackunwind....
-
Let's write a setjmp
https://github.com/samsquire/assembly/blob/main/coroutines.S
This might be useful to someone who wants to port this to C. This uses the stack switching idea. So they are stackful coroutines.
There's also Tina a header only coroutine library
textual
- Harlequin: SQL IDE for Your Terminal
-
Should you add screenshots to documentation?
The Textual project has a lot of screenshots in its documentation. These screenshots are built with the docs, so they are always up to date.
https://textual.textualize.io/
-
PysimpleGUI
Textual[0] does this for CLI apps. That’s not for full GUI apps, but it’s very DOM-like, uses CSS selectors, etc. and a cool option when it meets your needs.
[0] https://github.com/Textualize/textual
-
Using the Curses library on Windows - Terminal Display & Keys Input
For future projects that need a TUI beyond normal printing to a terminal, I'd recommend taking a look at Textual.
-
"<ESC>[31M"? ANSI Terminal security in 2023 and finding 10 CVEs
https://jupyterbook.org/en/stable/content/code-outputs.html#...
`less -R` is not the default.
FWIW, textual (and urwid) does ANSII escape codes well: https://github.com/Textualize/textual
touch file$'\n'name
-
logmerger - Text UI to view multiple log files with unified time scale
After installing logmerger, you can run a self-contained demo by running logmerger --demo, to view two log files before and after they are merged, and to play with the user-interface features provided by textual.
-
Ask HN: Why Did Python Win?
I think it just survived naturally, filling in the cracks left by Java / C++.
And not the era of Textual (https://textual.textualize.io/) is here, python may get the spotlight even more.
- FLaNK Stack Weekly for 21 August 2023
- Textual: Rapid Application Development Framework for Python
What are some alternatives?
continuation - Delimited Continuations for JavasScript
pytermgui - Python TUI framework with mouse support, modular widget system, customizable and rapid terminal markup language and more!
context
rich - Rich is a Python library for rich text and beautiful formatting in the terminal.
starfx - A modern approach to side-effect and state management for web apps.
python-prompt-toolkit - Library for building powerful interactive command line applications in Python
effection - Structured concurrency and effects for JavaScript
urwid - Console user interface library for Python (official repo)
stack-switching - A repository for the stack switching proposal.
asciimatics - A cross platform package to do curses-like operations, plus higher level APIs and widgets to create text UIs and ASCII art animations
cgreenlet - Coroutines for C/C++
npyscreen - Automatically exported from code.google.com/p/npyscreen