Some places are like that
You can run whenever you like, it doesn't have to be 6am
I'm fine with bank heists but please don't loiter :(
edit: English not my first language yada yada, I confused "loitering" for "littering"... I'm fine with loitering after all
S03 left the most memorable impression on me, I'd recommend powering through ;)
One workaround has been to spoof your Firefox user agent so Teams believes it's Chrome, and would you believe it the feature worked. I don't know if this trick is still relevant.
The message transferred between the particles supposedly FTL does contain information though. What I meant was that we cannot encode our own arbitrary information on top of it. The message has a physical effect on reality, without it the state we find the particles in cannot be respected.
Just reconsider this: If we agree that the result of a measurement is totally random (no hidden variable predetermining the result of the measurement) but that once we measure and know the state of one particle then we know with certainty the state of the other particle (entanglement): information about the collapse of the first measured particle was shared to the other so that it's no longer random.
edit: If your argument is about "sharing information doesn't imply transmission" then let's stop here and leave this thread agreeing that "information was shared" :)
I have no opinions on what shape the information sharing takes. Nor am I interested in guessing.
I mean you can setup a source of entangled particles and two very far detectors that would do measurements roughly at the same time on each particle in such a way that information traveling at the speed of light wouldn't have time to travel the distance between both detectors.
You can then just gather roughly simultaneous measurements and at a later time join the datasets from both detectors to see what one measured vs the other for each pair.
If I understand correctly the current observations show that collapsing the state of one of the particle influences the other all the way at the other detector. Since there's no hidden variables that predetermine the result of measurements while the result of the collapse is random, and the fact that particles still respect the correlation over any distance is why there seem to be a FTL communication between the particles.
Something has to be communicated between the particles for the influence to work FTL, but it also seem we cannot leverage this phenomenon to send "actual information" this way :/
edit: Important point with that experiment: once the particles have been observed, if you try the experiment a second time using the same particles, then you'll get different results, this time in line with hidden variables because the particle's state already collapsed.
The 2022 nobel prize was given to experimentalists that observed the violation of Bell's inequality.
https://en.m.wikipedia.org/wiki/Bell's_theorem https://en.m.wikipedia.org/wiki/Quantum_nonlocality
I'm genuinely not an expert but I get it to mean that there aren't hidden variables created alongside the entangled particles.
It's like piercings that healed except the hole is in the hands? I want to believe he did something so that they didn't have to mutilate his hands every 35 times they did this... But at the same time the face he makes when they remove the nails is not reassuring me :/
I wouldn't call that "messy and inefficient" but you do you. I'd be curious to know what's a "clean and efficient" solution for you when it comes to routing packets around the planet :)
Ever heard of CREDIT? /s
Long COVID Seems to Be a Brain Injury, Scientists Discover
Bad title maybe
By "the most exposure to writing code the better" I might have meant to expose people to as many paradigms and patterns as possible and them have dealt with it. i.e. Writing a (shitty) eventloop is what really made it stick for me with async/callback-based programming.
I'm not a good comment writer so here's some text:
Not a teacher, but Python is great to discover various aspects of programming (algorithmic, flow control, I/O, OOP, metaprogramming). It's also easy to setup.
Java is just painful. The environment setup and the various frameworks available there are just way too overwhelming.
JS is actually close to Python in my opinion, and better suited for getting introduced to functional programming while still using a non-functional language. See anonymous functions/arrow functions. APIs are heavily callback-oriented which is also a great thing to get used to: You can register a bit of computation (a function) to be executed some other time, i.e. when something happens. You are not in control of the execution of that function, someone else is and will call you back. This is something important to learn (imo).
Finding the optimum algorithm is not important in the beginning (imo). When writing code there's often two pretty different activities that happen:
-
Defining and organizing your abstractions and flow.
-
Identify bottlenecks and search for fast enough/memory efficient solutions.
In most real world scenarios, having good program flow and abstractions will be enough. Not everyone works on real-time terabyte-sized data processing. See gamemaking: it's a very performance sensitive domain yet frameworks allow anyone to make a decent game. Why? Because for most problems, someone already wrote a library that's fast enough. You just need to wire things properly together.
Teaching something lower-level like C/C++ is great, but you need to spend time deconstructing all the goodies people got used too when dealing with other languages. i.e. Why you can't create an array with different types/structs inside anymore (not without pointers).
And then just get them to practice writing different bits of software with increasing complexity, over the year(s). The most exposure to writing code the better. Trial and error is how anything is learned, and while you might try to warn your students about common pitfalls it might only really click once they'll make the mistake. Push them in situations where they'll make mistakes.
The most important mindset to have (imo) is to constantly challenge yourself and your work: find ways to break your own stuff. Maybe you'll miss cases but the better you get at anticipating breakage, the better you'll get at writing robust software.
The second most important thing is to seek to understand every line of code you write and as many implications as possible. A program is supposed to be deterministic, there's very few surprises to be had when dealing with code (there are some though). What I mean by that is: if someone reports a bug, it can often be enough to read the code with the unexpected result in mind and work your way back to the places that allowed for this bug to occur, just by reading statically.
Lastly one thing that was motivating for me when learning programming was when our programs would run against one another. Competition fosters innovation.
I hope these pieces of opinion help with anything...
You're right that this is not generating monetary gains
But it's generating outrage towards Google when what you accuse them of doing isn't the reality, that's pretty disingenuous
Not defending Google as a whole, but let's keep honest about the current developments
The day sponsored trips are the default is the day I'm dropping Maps
You're right that this is not generating monetary gains
But it's generating outrage towards Google when what you accuse them of doing isn't the reality, that's pretty disingenuous
Not defending Google as a whole, but let's keep honest about the current developments
The day sponsored trips are the default is the day I'm dropping Maps