Return Styles: Pseud0ch, Terminal, Valhalla, Blue Moon.

Pages: 1-4041-

making a debugging tool

Name: !Ps1ivhrO6w 2017-09-19 15:01

should I just give up?

Name: Anonymous 2017-09-19 16:46

Cudder-sama can make a better one.

Name: Anonymous 2017-09-19 17:36

Debugging is for Pajeets. Real programmers prove their programs correct.

Name: !Ps1ivhrO6w 2017-09-19 17:42

? - query - question mark
. - statement - full stop - dot
` - quasiquote - grave accent - backtick
' - quote
, - unquote

unquote -> don't quote (the default behavior)
quote -> do not resolve (throw errors) (query for the definition) (i.e. it is a symbol)

Ack? -> Ack.
Ack ack? -> Ack ack.
Ack ack ack? -> Ack ack ack.
Ack ack ack ack? -> Ack ack ack ack.

Ack. -> Ack ack.
Ack ack. -> Ack? -> Ack. -> Ack ack.
Ack ack ack. -> Ack ack? -> Ack ack. -> Ack? -> Ack. -> Ack ack.
Ack 0. -> 0? -> 0. -> Ack 0? -> Ack 0. -> 0? -> 0. -> Ack 0? -> Ack 0. -> ...
Ack I like apples -> Ack I? Ack like? Ack apples? (*)-> Ack I. Ack like. Ack apples. -> I? like? apples? -> I. like. apples. -> (goto *)

Ack 0 ack. -> Ack 0? Ack ack? -> Ack 0. Ack ack. -> 0? Ack? -> 0. Ack. -> Ack 0? Ack ack. -> Ack 0. -> 0? -> 0. -> Ack 0? -> Ack 0. -> ...
Ack '0 ack. -> Ack '0? Ack ack? - Ack '0. Ack ack. - Ack '0. Ack? -> Ack. -> Ack ack.

Name: Anonymous 2017-09-19 17:56


Name: !Ps1ivhrO6w 2017-09-20 3:16

Will she include it in the anonutils along with the disassembler?

Name: Anonymous 2017-09-20 3:22

Anoncoreutils? That's already out.

Name: Anonymous 2017-09-20 3:26

It will be included with the browser, actually.

Name: Anonymous 2017-09-20 8:15

formal proof is a pipe dream for most real-world software. to prove something, you need to formally specify it, and this is not trivial - constantly changing (e.g. ENTERPRISE) or difficult to define in objective terms (e.g. vidya) requirements are one thing, another is 'unknown unknowns' (e.g. maybe you have proven that your program correctly implements an algorithm - but that's not the only thing that can go wrong with software; security is the other, and because there are many different exploitation techniques, you can't just implement a single catch-all rule like 'it's not possible to write past the end of a buffer' and say that you've proven your program secure). so your 'real programmers' are mostly just the followers of the current academic fad

Name: !Ps1ivhrO6w 2017-09-20 13:00

structures and structural dependencies

* - first argument
** - second argument
*** - third argument
*^n - nth argument

( ) - select/precedence

(*) - identity
,(*) - eval
,(,(*) ,(*^2)) - apply

# - tag
'0 - literal

'(*) - tokenize

-> - replace
('0 -> '1) - replace rule
('0 -> '1)#S - tagged replace rule

+ 1
++ 2
+++ 3
+^n n

+- 0
- -1
-- -2
--- -3
-^n -n

-+ 0
-+- -1
-+-+ 0
-+-+- -1
-+-+-+ 0
-+-+-+- -1
-+-+-+-+ 0
(-+)^n 0
(-+)^n- -1

+^n n
+^n+ n+1
+^n++ n+2
+^n+++ n+3
+^n+^m n+m

*^+ - first argument
*^++ - second argument
*^+++ - third argument
*^+^n - nth argument

Name: Anonymous 2017-09-20 13:23

debug those dubs

Name: Anonymous 2017-09-20 14:01

No errors found.

Name: Anonymous 2017-09-20 14:03

thanks, I tried to make those dubs correct

Name: !Ps1ivhrO6w 2017-09-20 14:17

e.g. macro

('if 't (*^2) (*^3)) -> ,(*^2)
('if 'f (*^2) (*^3)) -> ,(*^3)
('if (*) (*^2) (*^3)) -> ('if ,(*) (*^2) (*^3))

Name: Anonymous 2017-09-20 21:04

real programmers just use printf

Name: Anonymous 2017-09-21 7:14


Name: Anonymous 2017-09-21 11:11

inserting printf every few lines and recompiling seems awfully efficient

Name: Anonymous 2017-09-21 23:32


Name: !Ps1ivhrO6w 2017-09-23 2:17

tentative factorial:

(0)! -> 1
(*)! -> (*)^((*)-)!

(since we aren't calling eval it means it's lazy)

Name: !Ps1ivhrO6w 2017-09-24 7:37

I'm thinking of using opengl for the math.
I'll research this option later.
Meanwhile, a message passing language like erlang and a regular shell for I/O operations like bash or sh seem like obvious choices to me.

Name: Anonymous 2017-09-24 14:59

Still waiting for cudder to make a better one.

Name: !Ps1ivhrO6w 2017-09-25 10:28

Conside this: XBF - eXtensible BrainFuck
Which template language would you use for it?

Name: Anonymous 2017-09-25 10:48

C preprocessor for the absolute 0 anal temperature

Name: !Ps1ivhrO6w 2017-09-26 11:20

Though they could have been done with macros, I decided to use truth tables.

and : (('t 't))
or : (('t 't) ('t 'f) ('f 't))
not : (('f))
xor : (('t 'f) ('f 't))
nand : (('t 'f) ('f 't) ('f 'f))
nor : (('f 'f))
xnor : (('t 't) ('f 'f))


Name: !Ps1ivhrO6w 2017-09-29 10:10

Name: !Ps1ivhrO6w 2017-09-29 11:43

To add: arithmetic zero can probably be represented as the empty string, or as ()
Fractions might be done as tuples, but this requires more framework.

Name: Anonymous 2017-09-29 13:20

>arithmetic zero can probably be represented as the empty string, or as ()
you're just a step away from Church numerals. unless your lists double as function calls like in Lisp, then you've reinvented Church numerals

Name: !Ps1ivhrO6w 2017-09-29 13:42

I need a way to model any and all behavior I encounter.

Name: !Ps1ivhrO6w 2017-09-30 8:20

and my inspiration is Peano, not Church

Name: !Ps1ivhrO6w 2017-10-01 19:06

Name: !Ps1ivhrO6w 2017-10-02 9:20

It seems to actually be a possible thing, which is strange.
Basically there'd be a ``controller'' written in XBF running on a terminal and evoking a different program, which it sandboxes into a virtual machine that turns all common instructions into XBF representations of them before they're dispatched, and then logs this in order to be able to model this program's behavior.

Correct me if I've made any conceptual mistake.

Name: Anonymous 2017-10-02 19:36

Not to mention the good old undocumented Intel instruction. Good job proving your software correct under a wrong hardware model.

Name: Anonymous 2017-10-03 13:59

I'm glad you understand the difficulties. Can the hardware itself be debugged?

Name: Anonymous 2017-10-03 22:14

If it's simple enough to disassemble, inspect under e.g. a microscope, and reassemble, then yes, in principle. With hardware that is simple enough, you could also try to feed it tons of data and check whether the behavior/output is appropriate. A sort of hardware unit test if you will.

With the (over)complex hardware you have today, probably not. The only good defense against hardware sabotage I can see right now is to make your hardware as general-purpose as possible. It's easy to hide a backdoor in a corner case of an AES instruction or an RNG within a CPU. If everything is e.g. RISC, doing something like this becomes either very expensive (and potentially noticeable when e.g. the multiplication instruction attempts pattern matching for RSA privates) or produces collateral damage.

But none of this protects you against straight-up bugs, like the inaccurate floating-point instructions on x86. As much as I hate to say this, it might be an unsolvable problem.

Name: Anonymous 2017-10-04 23:53

It's pretty much impossible to completely verify a processor's instruction set, but there is this, which gets fairly close:

Name: noko 2017-10-05 10:02

reported to intel

Name: Anonymous 2017-10-06 10:11


So many years spent developing CPUs, and they still can't implement x86 architecture properly.

Name: Anonymous 2017-10-06 23:09

the architecture is intentionally improper

Name: Anonymous 2017-10-07 9:31


It become even more ugly with each iteration.

Name: Anonymous 2017-10-08 2:32

It's to prevent reverse engineering

Name: Anonymous 2017-10-09 7:11

then it does a pretty shit job at that

Name: Anonymous 2017-10-09 11:25

see >>35

Name: !Ps1ivhrO6w 2017-10-15 21:09

Is SVG a lisp?

Name: Anonymous 2017-10-15 21:10


Name: Anonymous 2017-10-15 23:45

no it's a sgml

Name: Anonymous 2017-10-16 6:24

it might be. can you implement diff in SVG?

Name: !Ps1ivhrO6w 2017-10-18 13:21

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

Name: Anonymous 2017-10-18 13:27

probably, but why SVG?

Name: !Ps1ivhrO6w 2017-10-18 14:35

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.

Name: !Ps1ivhrO6w 2017-10-18 18:21

This is my progress so far.

Name: Anonymous 2017-10-18 18:29

thanks for not being all talk and no action

Name: Anonymous 2017-10-18 18:36

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

Name: Anonymous 2017-10-18 18:39


Name: Anonymous 2017-10-18 18:57


Name: Anonymous 2017-10-18 18:58

Nice job! Keep up the good work!

Name: Anonymous 2017-10-18 19:40

Is that the source code?

Name: Anonymous 2017-10-18 19:45

It could be.

Name: !Ps1ivhrO6w 2017-10-18 23:21

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

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

Name: Anonymous 2017-10-19 6:41

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

Name: !Ps1ivhrO6w 2017-10-19 19:54


Name: !Ps1ivhrO6w 2017-10-22 9:19

Consider Grammar: The language of languages

Name: !Ps1ivhrO6w 2017-10-24 8:48

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> )

Name: !Ps1ivhrO6w 2017-10-25 20:44

You can prove a debugging tool correct.

Name: !Ps1ivhrO6w 2017-10-25 21:00

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

Name: Anonymous 2017-10-25 21:48

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

Name: !Ps1ivhrO6w 2017-10-25 23:10

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.

Name: Anonymous 2017-10-25 23:39

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.
   /      \
  /  ─    ─\
/    (●)  (●) \ 
|       (__人__)    |
/     ∩ノ ⊃  /
(  \ / _ノ |  |
.\ “  /__|  |
  \ /___ /

Name: Anonymous 2017-10-26 6:52

to create a debugger from scratch you first debug a unvierse

Name: Anonymous 2017-10-26 7:23

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

Name: Anonymous 2017-10-26 19:33

Can your debugger debug itself?

Name: Anonymous 2017-10-26 21:50

That would be like dividing by zero.

Name: Anonymous 2017-10-27 0:52

But gdb can debug itself

Name: !Ps1ivhrO6w 2017-10-27 12:30

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.

Name: Anonymous 2017-10-28 23:46

Is the pope catholic?

Name: Anonymous 2017-10-29 2:05

Hard to tell with this Francis guy.

Don't change these.
Name: Email:
Entire Thread Thread List