The main reason most IDEs offer some sort of automatic code refactoring is to fix the formatting automatically. Actually works wonders sometimes ^ ^

Could also use y[x * 4000 + arr]

Sounds like an average codebase xD

Nach jeder Nutzung Löschung vordern ist möglich und rechtlich kein Problem. Es kann dann natürlich dazu kommen, dass dir die Dienstleistung (Nutzung der App) verwährt bleibt. Dann klappt's so auch nicht.

Ist trotzdem eine gute Idee und ich bin echt gewillt das mal zu machen, nur um denen ein wenig auf die Eier zu gehen xD

(Wobei ich, statt nach jeder Nutzung, einmal pro Monat bevorzugen würde. Ist weniger Papierkram)

My OS is written in asm, so it's OK, right?

There are 2. Shor's factorization (the famous one) breakes RSA. Shor's dlog breaks DH and ECDH and all systems building up on this (like DSA and ECDSA). dlog can in theorie also break some security promises of RSA ^ ^

The only problem with these algos is, that current qc cannot represent the whole problem within it's qbit storage. ECDSA allow the smallest bitlenghts, so getting them into a qc is probably the first

I also cannot wait to see the big corps move to ecdsa because they believe shor's algo only breaks RSA even though ecdsa gets broken even earlier xD

0000

The question is not about having a fully functional fault tolerant qc. It's about having one that can handle 2n linked quantum states.

I can already imagine big corps just going to RSA-2048, once a 2048 qbit computer exists and RSA-1024 is broken. And then going up to RSA-4096 once a 4096 quit computer exists and RSA-2048 is broken and so on...

You could also compile with -fsanitize-address to let the compiler add a little check before every memory access. There are many options for checking memory safety. Still doesn't mean everybody will use them :/

Also as a site note: All good memory safety check techniques perform a runtime analysis. This can of cause be combined with a fuzzy testing tool but that is even more uncommon. So you can safely assume the program does not leak in the standard/test cases but how about this specific chain of events that never really hot tested?

Also, the meme is not about memory leaks. In security the term 'memory safety' is not about memory leakes but about unallowed memory access. While these tools might find buffer overreads/overwrites in the standard case, it will not find it in case of a following packed struct member, so these tools have limits. Also most attacks are about finding a very specific input that no one ever expected to happen, so again it will probably never be tested in the runtime analysis. Sometimes, even fuzzy testing would not make a difference.

And as somebody who has studied that security stuff, I can say: It's not easy to write a secure program if you don't know what attacking techniques even exist and what to look out for in the oen code. So it's not unexpected that people without the knowledge will create security problems. I would also not generally blame C for all security problems. Yes, the language is dangerous, but if handled carefully, it can be even more secure. At least for some very specific purposes xD

Some of these rules also enforce rounding to be done in decimal, which can get quite problematic as float/double round in binary if the value does not fit into the data type...

I can verify the not always. I can also make an insulation look like the pride flag xD

You mean an interface for a coffee machine. HTTP 418 states that the coffee machine refuses to brew coffee anymore and is a teapot now. The protocol is about coffee, just the error message is about tea xD

It was not the only source if randomness and it was not an abuse of the language. It was the get random function that get passed an array to fill with random data. In an It is always nice to get entropy from as much places as possible, this function first read the array to add it to the entropy pool. The pool cannot get worst, but it can get better through this.

Problem was that some other function passed an uninitialized array to the get random function, so the get random read that uninitialized array... It was completely on the maintainer to comment that code section out without understanding what was going on.

Also it only caused problems on systems, that had no better source of entropy and had to generate some certificate immediately after boot up, so that even runtime was not random enough. Where still enough to cause problems till today xD

Algorithms also existed (in the field of math) long before computer science was a thing. Just look at techniques to calculate something with big numbers by hand. Division, square root, gcd, ...

Install greek as a second keyboard layout. It's pretty useful, especially for physical equations ^ ^

Not exactly. The OS sends a SIGSEGV to the process. This triggers the event handler for this signal to be executed. The standard event handler for SIGSEGV looks like {fputs("Segmention fault", stderr);exit()}.

This code is put there by the C compiler if there is no event handler for SIGSEGV defined. The standard event handler could print more information, but so could the programmer, if they define their own event handler.

The reason this exit is mandatory at the end of the event handler is also quite simple: when returning from the event handler, the code which was interrupted by the event gets continued. The command, which caused the segfault did not finish, so it gets re-executed, causing the segfault to repeat...

So, the OS does not kill the program. It just informs the program that the memory read it tried got outside the assigned memory segments. The program then kills itself xD

You fucked up a pointer. Isn't that obvious enough? xD

Just thinking about it: „Gänsefüßchen” would also allow for string in string constructs without escaping. Now, I want to modify some compilers xD

The last line could be more structured. How about:

"([Ff]ound the )|(FOUND THE )[a-zA-Z]+"

Lizard men confirmed?

Nah. The trick is to write it with the least amount of characters. I'm to lazy to write readable code xD

You know there is a type for when you don't want to decide on the type?

It's called void*

/s

1.12.2 is fine, but if you really want to have a lot of mods, good old 1.7.10 is the one xD

Well first they gotta rewrite a Browser xD