overfl0w

It's unbelievable that the average human being has access to the lectures of some of the best universities in the world for free. 31 hours of in-depth mathematics by some of the best people in their field.

Although I have always been struggling with keeping up with long lecture playlists. I always try to find shorter videos which explain the concept faster (although probably lacking depth). And end up ditching it halfway as well. Perhaps the real motivation to keep up with the material comes from actually enrolling the university? Has anyone completed such type of lectures by themselves? How do you stay consistent and disciplined?

I find courses in some platforms (coursera/khanacademy) a bit more motivating because they kind of push me with deadlines. I guess I am used to deadline-oriented studying.

If anyone else is struggling with attention span and is looking for shorter lectures (although they may not have the same depth): https://www.youtube.com/@ProfessorDaveExplains/playlists

This reminds me of Asimov's Jokester story where the same themes are explored - there is an all-knowing computer but someone needs to ask the correct questions.

"Early in the history of Multivac, it had become apparent that the bottleneck was the questioning procedure. Multivac could answer the problem of humanity, all the problems, if it were asked meaningful questions. But as knowledge accumulated at an ever-faster rate, it became ever more difficult to locate those meaningful questions. Reason alone wouldn't do. What was needed was a rare type of intuition; the same faculty of mind (only much more intensified) that made a grand master at chess. A mind was needed of the sort that could see through the quadrillions of chess patterns to find the one best move, and do it in a matter of minutes."

This fallacy also assumes that free will exists (it does not) and you could have made different choices (you couldn't have). Accepting that your choices are not free and are influenced by multiple factors (such as your current state, your knowledge at the time, your emotions, your past, upbringing, genetics even, the people you interact with) makes you realize that regret is meaningless.

The bug in question was a out of bounds writing to a stack allocated buffer. The compiler would choose to store some variables to registers for optimization purposes. When calling a function - these registers' contents would get pushed to the stack. The faulty called function would modify those same register contents on the stack. When returning to the parent function and restoring the context - the registers would have faulty values.

When adding a print or a check - the compiler would choose different variables to store in the registers. They would still get overwritten by the faulty function but the bug would not be observed.

I agree that it's almost never the compiler's fault though - but sometimes its optimization choices make it harder to reproduce a bug.

Edit: The faulty function was a somewhat standard function, part of the SDK. This taught me that the standard functions are almost never faulty. Until they are :-)

Those are the kind of bugs one remembers for life.

And then there are those rare cases where inserting a print or a new condition to use for conditional breakpoint forces the compiler to output slightly different code which does not produce the bug. Essentially this is similar to the Observer effect in quantum mechanics where the system is disturbed simply by observing it. Also the bug cannot be reproduced with optimizations disabled.

How are those cases debugged then? By enabling the debug symbols AND the optimizations and using the debugger, looking at the code and the disassembly side by side and trying to keep your sanity as the steps hop back and forth through the code. Telling yourself that the bug is real and it just cannot be reproduced easily because it depends on multiple factors + hardware states. Ah! I sometimes miss those kinds of bugs which make you question your reality.

This sketch is a gem, I liked it! It is absolutely correct - people can and will divide if this is their goal. Sadly this mass social disintegration on all levels affects negatively various free software products. I don't even hold any extreme political beliefs (I think) but nevertheless I avoid discussing any politics in any professional environment because it's just not the place for these types of discussions and it usually doesn't lead to anything constructive or positive. I never cared what my peers' political/religious beliefs were and through the years never had problems with any of them. It was a simple life - as long as all of us did our job the final products were of decent quality.

Perhaps some kind of a policy which would treat politics as off-topic and would discourage discussing it would be beneficial to such projects in the long run.

That's not quite true though. Developers, contributors and financial supporters have been banned.

"In a particularly peculiar move, a "Titanium Level" financial supporter of Godot was blocked during this mass banning campaign."

https://lunduke.locals.com/post/6171454/godot-game-engine-en...

In my opinion politics should stay out of software but sadly it gets harder and harder every day. In any case - banning people (some of them contributors and developers) from all platforms only because they suggested that Godot should "focus on software instead of politics" is terrible and harms the project and its community. And all of this started because of a woke tweet which had nothing to do with Godot engine whatsoever. We are living in interesting times. I hope Godot does not follow all the other companies who walked the "go woke go broke" route.

Good article, also has references to the glib's source. I've never dived deep into the random() system function before. This is from the man pages:

"The random() function should not be used in multithreaded programs where reproducible behavior is required. Use random_r(3) for that purpose."

Perhaps the notes should be updated to state that the performance of multi-threaded programs is also affected due to the shared global resource?

RC Cars

In terms of capability, I speculate that the best an attacker can achieve is a sticky, privileged process that accepts arbitrary commands at runtime, which can be used to read the disk, analyze other running processes, install and exfil sensor data, etc.

The worst-case scenario would be if the attacker somehow manages to rewrite your motherboard and/or SSD's firmware with a malicious firmware. And even if you reinstall your OS - he still manages to re-install the rootkit afterwards. I've only read about such type of malware but never have I seen or heard of anything like that in the wild.

The ranges mentioned are in BGN. Nobody will pay 1.5k - 2.5k EUR to a junior.

source: I work there

Also this: https://noblehire.io/salary-survey-2021/

This is why I believe there should be no downvote at all. Or there should be a way to see which posts are the most controversial instead of hiding them. When someone disagrees with an opinion and downvotes it - they bury it and in a way hide it from the world. This behaviour is what creates echo chambers where only the popular opinions are amplified even if they are wrong.

Yes, this is it, thank you for providing the source, it was an interesting read.

Great work! I liked how well the vintage look and the modern core fit.

I'm not sure where I read it but it was stated that the Geiger counters which are manufactured after the Chernobyl (?) incident were not as accurate as those manufactured before it. The reason is that all the metal after the incident and the radiation experiments performed afterwards is contaminated with radiation particles which alter the radiation readings of the Geiger counter. Correct me if I'm wrong about this one.

Sure but they are not in a public git repo and I think the public has the right to see the full story. The police are the easiest target right now but those people who take advantage on the riots to loot are kind of left out of sight.

Now all we need is a similar repo for the looting and memorial vandalism.

Can memory safety be ensured in the C programming language? By static analysis at compile time for example?