openscad-graph-editor

Blockly? I've been using it BlockSCAD: https://www.blockscad3d.com/editor/ and apparently it can be used in Jupyter notebooks? https://jupyterlab-blockly.readthedocs.io/en/latest/ Or perhaps a node programming system such as: https://nodezator.com/ https://ryven.org/ or https://github.com/derkork/openscad-graph-editor

Excellent points. (much of the below has been posted in other discussions here, my apologies to folks who are seeing it for the _n_th time) This is a sort of tool I've believed in/wanted for a long while (and I've been funding the author and chatting with him on Discord and via e-mail), but there seem to be a few fundamental issues which good answers need to be found for: >What does an algorithm look like? Can such visual tools be expressive enough to justify the effort? They seem to work well for problems which can be expressed as one screen of diagram --- and while making modules would seem an easy way to increase the complexity, this goes against the initial mode of expression and if overdone, results in the wall-of-text one is trying to escape from, just dressed up in colored boxes and lines. Once one starts to scroll, or can't see th

Quite a different problemspace, but there is: https://github.com/derkork/openscad-graph-editor which allows programmatic 3D modeling using nodes/wires. It exposes _all_ of OpenSCAD (last I checked) and is quite extensible (I use it to control a Python-enabled version of OpenSCAD https://pythonscad.org/ in an effort to make DXFs and G-code: https://github.com/WillAdams/gcodepreview )

Why did it have to be pixelated in appearance? It would be far more attractive as anti-aliased vector lines and type. The red highlighting reminds me of electricity in the classic circuit problem game _Rocky's Boots_ on the Apple ][. As I've posted in similar discussions: https://news.ycombinator.com/item?id=42051536 The problem here, as always is that there isn't an agreed-upon answer for the question: >What does an algorithm look like? The problem is expressiveness of such a diagram is bounded by the size of a screen or a sheet of paper, and once one starts to scroll, or can't see the entire flow at a glance, things get complicated. The node/wire programming folks have this a bit rougher to the point that there are sites such as: https://blueprintsfromhell.tumblr.com/ https://scriptsofanotherdimension.tumblr.com/ I prefer to work visual

I believe that the problem here is that there isn't an agreed-upon answer to a fundamental question: >What does an algorithm look like? The problem is expressiveness of such a diagram is bounded by the size of a screen or a sheet of paper, and once one starts to scroll, or can't see the entire flow at a glance, things get complicated. The node/wire programming folks have this a bit rougher to the point that there are sites such as: https://blueprintsfromhell.tumblr.com/ https://scriptsofanotherdimension.tumblr.com/ I prefer to work visually, but not sure if that's actually valid --- unfortunately https://www.blockscad3d.com/editor/ doesn't support all of OpenSCAD and https://github.com/derkork/openscad-graph-editor has problems with a stylus (I have to leave the Windows Settings app open to toggle stylus behaviour which is enough friction

Parallel track: - MacBASIC: Mac GUI programming w/o Pascal or C https://www.folklore.org/MacBasic.html (which is something I'll never forgive Bill Gates for) - HyperCARD (also on that list, and agree with almost all points made): It was magic to get into Developer mode and to create stacks --- it's unfortunate that Asymetrix Toolbook didn't get further, nor that the Heizer stack for converting HyperCard stacks to Toolbook wasn't more widely available, and a shame that Runtime Revolution which became Livecode reneged on their opensource effort --- hopefully someone will make good on that: https://openxtalk.org/ Unfortunately, I never got anywhere w/ Interfacebuilder.app or Objective-C.... - Lua: real variables in TeX! (and latex), and one gets METAPOST as well --- even recursion becomes simple: https://tex.stackexchange.com/questions/72389

Well, there is at least one effort at a solution: http://literateprogramming.com/ and I've found that John Ousterhout's recent book, _A Philosophy of Software Design_ is one of the most notable programming books of the past decade and speaks to many of these difficulties so well that I added it my effort at a list of (mostly) Literate Programming books: https://www.goodreads.com/review/list/21394355-william-adams... The other issue here is the still unanswered question: >What does an algorithm look like? and by extension, the further question of: How does one manage a visual representation of a program when it gets beyond the size of one screen/window, or a page in a book, or for the largest ones, a poster? With a bit of help of tex.stackexchange.com I was able to put together a Literate Programming system which allows me to use (La)TeX w

Nice! Great to see (Open)PythonSCAD listed! (I know this sort of thing is hard to keep up with --- I was trying for a long while on the old Shapeoko wiki (see link elsethread)). (below has been edited to reflect my reading the entire page) A tool which I didn't find and thought wasn't included is: https://github.com/derkork/openscad-graph-editor (which I was expecting would fall under "GUI", but is instead near the end under "Wrappers")

I bought into Plasticity in the hope that it would gain such facilities, but the dev said that that sort of thing was being pushed off to v3. Tried Dune3D and was moderately successful, but couldn't see where in the U.I. such numeric/programmatic access would be afforded and it doesn't seem to be on the roadmap there either. I suppose I should break down and buy Rhino 3D and use Grasshopper, or Moment of Inspiration and use its Node Editor, but for now, I've been using: https://github.com/derkork/openscad-graph-editor

The amazing thing to me is that PythonSCAD is useful just for allowing access to variables and being able to write out files --- and it allows encapsulating those capabilities in "normal" OpenSCAD so that it is then possible to use them in a supporting tool such as: https://github.com/derkork/openscad-graph-editor see: https://raw.githubusercontent.com/WillAdams/gcodepreview/mai... and the matching: https://raw.githubusercontent.com/WillAdams/gcodepreview/mai...

The problem with this sort of thing is that there doesn't seem to be a consensus on: >What does an algorithm look like? I like to at least pretend that I'm a visual person (have to justify my BFA in graphic design _somehow_), and usually reach for: - https://www.blockscad3d.com/editor/ (a Blockly version (think Scratch) of the 3D programming system OpenSCAD) or - https://github.com/derkork/openscad-graph-editor and have been funding the guy behind http://nodezator.com/ for a while now. I suppose I should try https://ryven.org/ again... The thing is, the ability to express complexity is sharply bounded by display size (and maybe some aspect of human cognition such as the gestalt theory about the number of objects which may be perceived at a glance) --- for a textual program, one has an essentially infinite 2D canvas which scrolls up/down -

I'd give a lot to have a graphical development environment which: - allowed drawing a user interface as naturally as I used to use Altsys Virtuoso (or Macromedia Freehand which I moved to when my Cube stopped working) - allowed programming the UI as naturally as HyperCard (and to a lesser extent Lisp) "clicked" for me - was as visual as Google's Blockly (which as BlockSCAD: https://www.blockscad3d.com/editor/ I've used a fair bit) - exposed variables in a mechanism like to OpenSCAD's Customizer: https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Customize... Currently plugging away with OpenSCAD Graph Editor: https://github.com/derkork/openscad-graph-editor but hoping that: http://nodezator.com/ will become a viable option (still a bit bummed that I rolled and crashed w/ https://ryven.org/ though in retrospect, maybe I should try to tie t

I use such tools when I can, and am fascinated with the concept, since it evokes Herman Hesse's _Glass Bead Game_ (from his novel _Magister Ludi) which was a book I remember fondly from my youth. Advantages are: - discoverability --- it seems pretty easy to arrange all elements in a hierarchy and make them accessible via clicking/revealing - no syntax errors --- if things fit together/connect, then it should be a syntactically valid program The problem is, it relies on a couple of concepts we don't seem to have a good solution for: - What does an algorithm look like? - How to deal with an algorithm which is larger than the current screen/window size? (it's all-too easy to have the same sort of problem of a not-wrapped program with lines longer than the current window size and more lines than will fit in a window, and there doesn't seem to

Yeah, one of the best programmers I've ever worked with would launch Epsilon (a commercial emacs style editor for various OSs) each morning and then do _all_ of his work from it. The closest I come to that is messing emacs keyboard shortcuts when I'm not using a Mac. I really wish that there were more programs which completely re-examined all aspects of various tasks _and_ incorporated scripting in a fashion which allows folks to take advantage of it. Some of the apps I would consider if putting together such a list: - LyX --- billed as a "What You See is What You Mean" Document Processor, v2.4 is looking to be quite promising... - TeXshop/TeXstudio --- the former in particular is _very_ nice for folks who aren't able to devote the effort to learning emacs - pyspread --- have a spreadsheet where every cell can contain a Python program or

I really wish Livecode hadn't pulled their opensource/Community Edition (and I'd be very glad for someone to do something with that code). Gambas is something I keep wanting to try and seems promising. EDIT: Other BASIC options include Twinbasic (looks to be stalled though) and Small Visual Basic. I did one small app w/ Python and TKinter, but it was a dense wall of text/code when I was finished and not something I was interested in revisiting. I keep seeing suggestions that Python w/ QT support is supposed to be quite good. One unlikely option is Google's Blockly (which I wish had a stand-alone desktop implementation which would make graphical programs), which has a nifty version implementing OpenSCAD: https://www.blockscad3d.com/editor/ which I've used a fair bit. Moving on from there, there is: https://github.com/derkork/openscad-graph