I've always wanted better tools to read and navigate—not edit!—source code.
-
I've always wanted better tools to read and navigate—not edit!—source code.
For example, it's incredible to me that there is no iPad app that does LSP features plus bookmarks, navigation tree, etc.
Maybe now that LLMs made it more people's job to read code, we'll get good code reading tools?
-
I've always wanted better tools to read and navigate—not edit!—source code.
For example, it's incredible to me that there is no iPad app that does LSP features plus bookmarks, navigation tree, etc.
Maybe now that LLMs made it more people's job to read code, we'll get good code reading tools?
@filippo I expect treesitter would be a good fit for this, like https://difftastic.wilfred.me.uk/
Regardless of LLM involvement, would be cool for it to be explored a bit. I remember coming across something like this idea, but failing to recall what it was.
-
I've always wanted better tools to read and navigate—not edit!—source code.
For example, it's incredible to me that there is no iPad app that does LSP features plus bookmarks, navigation tree, etc.
Maybe now that LLMs made it more people's job to read code, we'll get good code reading tools?
@filippo probably not necessarily fit for your specific use cases, but take a look into features/design patterns behind searchfox.org which current only indexes firefox, thunderbird, webkit etc.
-
@filippo probably not necessarily fit for your specific use cases, but take a look into features/design patterns behind searchfox.org which current only indexes firefox, thunderbird, webkit etc.
@freddy nice! I am a big fan of codesearch tools (https://cs.opensource.google, https://codesearch.debian.net, Livegrep) but they are not a full UX that explores how to make code accessible and understandable.
-
I've always wanted better tools to read and navigate—not edit!—source code.
For example, it's incredible to me that there is no iPad app that does LSP features plus bookmarks, navigation tree, etc.
Maybe now that LLMs made it more people's job to read code, we'll get good code reading tools?
How come we have not seen any experimentation with linking code blocks in 2D space, or with making lexical scopes first-class UI elements (beyond the anemic block folding of IDEs), or with doing logic-based visual refactors one the fly (e.g. show me this function's logic when foo is true).
Code is an easily analyzed and manipulated tree with readily accessible invariants and properties... and we universally show it as a list of Unicode character lines. Why!
-
How come we have not seen any experimentation with linking code blocks in 2D space, or with making lexical scopes first-class UI elements (beyond the anemic block folding of IDEs), or with doing logic-based visual refactors one the fly (e.g. show me this function's logic when foo is true).
Code is an easily analyzed and manipulated tree with readily accessible invariants and properties... and we universally show it as a list of Unicode character lines. Why!
@filippo AOP hinted in this direction a few decades ago.
-
How come we have not seen any experimentation with linking code blocks in 2D space, or with making lexical scopes first-class UI elements (beyond the anemic block folding of IDEs), or with doing logic-based visual refactors one the fly (e.g. show me this function's logic when foo is true).
Code is an easily analyzed and manipulated tree with readily accessible invariants and properties... and we universally show it as a list of Unicode character lines. Why!
@filippo Totally agree. LSP itself doesn't have enough features - you'd either need to rely on custom extensions, or have per-language support on the frontend, but yes, viewing code through a 2D grid of characters in files seems, in many ways, pretty weird.
-
How come we have not seen any experimentation with linking code blocks in 2D space, or with making lexical scopes first-class UI elements (beyond the anemic block folding of IDEs), or with doing logic-based visual refactors one the fly (e.g. show me this function's logic when foo is true).
Code is an easily analyzed and manipulated tree with readily accessible invariants and properties... and we universally show it as a list of Unicode character lines. Why!
with linking code blocks in 2D space
this happens a lot in the HDL space and it's fucking awful. EEs do it for some reason and beyond some (quite small) threshold of complexity you yearn for the sweet release of death^W code, which is actually one of the reasons people use Amaranth
with making lexical scopes first-class UI elements (beyond the anemic block folding of IDEs)
we have tried it and it sucks because you cannot represent intermediate illegal states that arise a lot during editing
or with doing logic-based visual refactors one the fly (e.g. show me this function's logic when foo is true).
this would actually work very well
-
How come we have not seen any experimentation with linking code blocks in 2D space, or with making lexical scopes first-class UI elements (beyond the anemic block folding of IDEs), or with doing logic-based visual refactors one the fly (e.g. show me this function's logic when foo is true).
Code is an easily analyzed and manipulated tree with readily accessible invariants and properties... and we universally show it as a list of Unicode character lines. Why!
@filippo You want 2D programming? How about https://en.wikipedia.org/wiki/Befunge ;)
-
Drummer, shipped in 2021 or so, is an outliner that has built in scripting.
https://docserver.scripting.com/drummer/scripting.opml
Going back to the late 70s that was what got me interested in outliners, that they were such a natural way to write software.
I write all my apps in Drummer, btw. Look through my repos on GitHub, there's usually a source.opml file in each folder that contains the code I edit.