Writem | simple web app built using Python-Flask

Error output is going to stderr. Use IPC::open3 to capture it.

Per @ikegami's comment: Using open3 to read both STDOUT and STDERR is extremely complex. Continue using open2 but adding 2>&1, or use IPC::Run

As hashed out in the comments.

You can not sign a certificate as a trusted CA (if you could why would you ever trust the CA?).

You have to generate a CSR (Certificate Signing Request) and send this to the CA for them to sign it (and usually charge you for it). They will also prove that you own the domain the certificate will represent. (LetsEncrypt does this all for you using the certbot tool and will do it for free).

Also no trusted CA will ever sign a certificate for localhost.

fs.writeFile's last argument should be a callback function. Right now, you're missing it:

fs.writeFile(...) requires a third (or fourth) parameter which is a callback function to be invoked when the operation completes. You should either provide a callback function or use fs.writeFileSync(...)

See node fs docs for more info.

You need to cast your obj variable using the actual class that contains the method.

By changing your function to use preg_split to split the string on any non-alphabetic characters, you can extract only the words for capitalisation. By using the PREG_SPLIT_DELIM_CAPTURE flag we retain all the non-alphabetic characters and we can then put the string back to together by using implode with no glue:

At tick 7+ CPU has to perform instruction MD=D-1 as you figured out already.

At this point D=11111.

Instruction is D-1 and the CPU will internally calculate this value, so outM( output bus, not actual memory) is D-1 (11110) and register D = 11110 as well. At tock 8 write to memory happens so 11110 is saved at address in register A. CPU still calculates D-1 so outM = 11109, completely correct behaviour of CPU, we don't use this value but it represents result of last instruction (still D-1).

To expand on ticks and tocks:

tick is the 1 on clock, it's the part of the cycle where all outputs and registers have time to change and stabilize their internal values. Registers being loaded output their changing internal state immediately as input changes.

tock is the part that clocked parts start emitting their internal state and won't change their internal values.

That's why DRegister has the same value as outM on tick, ALU feeds D-1 as their value. Then comes tock and D starts emitting its new value(d-1) and ALU calculates its new value (you see it as D-2). D doesn't change because in tock phase clocked parts don't change their value.

Also to answer

How does it happen that RAM[A] and D end up with different values

They don't, outM and DRegister end up with different values. outM is not clocked, it's direct output of ALU, which calculates out(D) - 1. DRegister has the same ALU output as an input but it won't update its value because of clock phase.

Not sure if this might address your problem. Maybe, try something like this to see, where your data might be written:

It is tricky to answer these kinds of questions without doing the work for you, which isn't helpful to you in the long run.

Some general thoughts.

• Consider each element in isolation (including the circles where signals come together).

• Label each line between elements with a name. These will become internal control lines. It helps reduce the chances of confusion.

• Be very careful about junk outputs. If you're not supposed to be putting valid data on outM, use a Mux to output false.

Potential gotcha: I seem to remember that it's a bad idea to use a design output (like outM) as an input to something else. Outputs should only be outputs. Right now you are sending the output of the ALU to outM and using outM as an input to other elements. I suggest you try outputting the ALU to a new signal "ALUout", and using that as the input for the other elements and (through a mux with false controlled by writeM) outM. But remember, writeM is an output! So the block that generates writeM needs to generate a copy of itself to use as the control to the mux. FORTUNATELY, a block can have multiple out statements!

For example, right now you're generating outM like this (I won't comment on whether it is wrong, I am just using it as an illustration):