making a debugging tool

should I just give up?

>>40
then it does a pretty shit job at that

>>41
see >>35

Is SVG a lisp?

Absolutely.

>>43
no it's a sgml

>>43
it might be. can you implement diff in SVG?

I was wondering if SVG can be used to define 3d objects to feed to a 3d-rendering engine.

>>47
probably, but why SVG?

>>48
Because it is an XML, an open web technology and abstract syntax tree friendly.

I would like to model some physical things and deduce properties from geometry. Circuits and such too.

https://github.com/Capaverde/XBF

This is my progress so far.

>>50
thanks for not being all talk and no action

>>51
That's being very rude to one of the few people on here who does things at least remotely related to programming.

>>52
???

>>53
¿¿¿

>>50
Nice job! Keep up the good work!

>>50
Is that the source code?

>>56
It could be.

>>56
It's the schematics for the implementation of an interpreter and then maybe a compiler. Basically all 'definitions' or 'declarations' should run without error and the expected behavior (or expected interpretation, or expected result) is explicified (see arithmos, logic, topos)

It is not completely standardized yet, and the acknowledger is held somewhere else. But the acknowledger (or acker) should go into grammar and rhetoric, for querying a knowledge base and forming equivalent statements in different languages.

To interface with other programs is tricky, but it is something of an end goal. I need to review some basic circuitry stuff, flip-flops and timers, to implement chronos. I was also thinking of feeding it an oscillator from the architecture/hardware or OS, but I still need to see how it could be done.

More on ackers can be seen here

https://pastebin.com/BGirdCMA
https://pastebin.com/ii8EH6pS

I have some other things which I have not yet transcribed.

so I have no idea what you're trying to achieve but it's interesting anywa

000|010|110|100|101|111|011|001

Consider Grammar: The language of languages

http://matt.might.net/articles/grammars-bnf-ebnf/

Tentative rules for the operations I have so far
<positive> ::= +
<positives> ::= <positive> | <positives> <positive> | <positive> ^ <integer>

<negative> ::= -
<negatives> ::= <negative> | <negatives> <negative> | <negative> ^ <integer>

<sum> ::= <positive> ^ <integer> <positive> ^ <integer>

<subtraction> ::= <positive> ^ <integer> <negative> ^ <integer>

<multiplication> ::= ( <positives> ) ^ ( <positives> ) | ( <positives> ) ^ ( <negatives> )

<exponentiation> ::= + ( ^ <positive> ^ <integer> ) ^ ( <positive> ^ <integer> )

>>3
You can prove a debugging tool correct.

>>59
It was originally >>31 but now I want to make it general purpose.

What I am read? Please explain, I do not know.

>>65
Sure. Simply saying, it'd be a self-defeating effort if the debugging tool was itself faulty. And now I've come at odds with faulty architectures the tool would run on.
What it could do instead is ``hijack'' the architecture from the inside, having only a very limited set of commands which the user, through an input method, would config by means of analog commands in the used architecture. Then the debugging tool would effectively run assembly with all the expressivity its DSL allows.

>>66

Sure. Simply saying, it'd be a self-defeating effort if the debugging tool was itself faulty. And now I've come at odds with faulty architectures the tool would run on.
What it could do instead is ``hijack'' the architecture from the inside, having only a very limited set of commands which the user, through an input method, would config by means of analog commands in the used architecture. Then the debugging tool would effectively run assembly with all the expressivity its DSL allows.

　 　　　＿＿＿_ 
　　　／　　 　 　＼ 
　 ／　　─　 　 ─＼ 
／ 　　 （●） 　（●） ＼　 
|　 　　 　 （__人__）　 　 | 
/　　　　 ∩ノ ⊃　　／ 
(　 ＼　／ ＿ノ　|　 | 
.＼　“　　／＿＿|　 | 
　　＼ ／＿＿＿ ／

>>66
to create a debugger from scratch you first debug a unvierse

debugger can be defined as a program which outputs bugs in target program. in a way, it can be seen as a program which takes a buggy program as its explicit input and also implicitly takes its ideal non-buggy version. with such generalization, the way of creating a debugger becomes clear: lets see these guys implement diff

>>66
Can your debugger debug itself?

>>70
That would be like dividing by zero.

>>71
But gdb can debug itself

>>70
It cannot be both inside and outside a sandbox. But if there are two instances, sure. (Say one is an older version or there has been a fork.)

Writable xor executable. It can be told to load a copy inside a sandbox and this copy loads a different program inside a sandbox that is inside the first sandbox. Then it watches as this copy debugs the other program, logging its actions and such. There'd be no forkbombs because the sandbox (which is a XBF VM) would have a memory limit set.

There are other possibilities like a negotiator instead of a controller, and you don't need the first sandbox because it is redundant.

User input would be necessary to decide what to do with the logging, or it could be automated.

Alternatively, each instance would have a ``knowledge base'' that can be read and written to and the executable part that queries it or sends messages to another acknowledger that queries its own logs for the response.

>>70
Is the pope catholic?

>>74
Hard to tell with this Francis guy.