These three constructs do three different things, without overlap
- mylist[::-1] returns a reversed clone
- mylist.reverse() is a void in-place mutation, same as mylist.sort()
- reversed(mylist) returns an iterator, not printable but can be used as argument to some other functions
- I feel this can be convenient in some contexts.
- reversed(myStr) works too but you can’t print it directly
- Unlike items(),
- sorted(any_iterable) returns a new vector (i.e. “list”). Returning an iterator would be technically stupid.
https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html (java8) shows two nice tables:
- There’s no more “private protected“
- default access level is better known as “package-private” — strictly more private more restrictive than Protected . (Protected is more like Public). The 2nd table shows that
- a “package-private” member of Alpha is accessible by Beta (same package) only, whereas
- a “protected” member of Alpha is accessible by Beta and Alphasub
- Therefore, “neighbors are more trusted than children”
I find it hard to remember so here are some “sound bytes”
- “protected” keyword only increases visibility never decreases it.
- So a protected field is more accessible than package-private (default) field
- As an example, without “protected” label on my field1, my subclasses outside the package cannot see field1.
- same-package neighbors are local and trusted more than (overseas) children outside the package, possibly scattered over external jars
For a “protected” field1, a non-subclass in the same package can see it just as it can see a default-accessible field2
Not mentioned in the article, but when we say “class Beta can access a member x of Alpha”, it means that the compiler allows you to write, inside Beta methods, code that mentions x. It could be myAlpha.x or it could be Alpha.x for a static member.
A CVA interviewer asked me to explain the cmpxch cpu-instruction. I now believe it COMPARES two values (expected^current) and IIF matched, updates the memory location to a “newValue”.
Out of these 3 “inputs”, only the expected and newValue are inputs to the function. The 3rd item “current” is NOT an input parameter to the function, but discovered in the hardware.
See P1018 [[the c++StdLib]] by Josuttis
This knowledge is slightly below java API
I guess you could simulate broadcast using TCP. You may need to maintain 5 sockets to 5 clients…
I think this is highly inefficient.
This was actually asked in an interview, but it’s also good GTD knowledge.
https://stackoverflow.com/questions/4012498/what-to-do-if-debug-runs-fine-but-release-crashes points out —
- fewer uninitialized variables — Debug mode is more forgiving because it is often configured to initialize variables that have not been explicitly initialized.
- For example, Perhaps you’re deleting an uninitialized pointer. In debug mode it works because pointer was nulled and delete ptr will be ok on NULL. On release it’s some rubbish, then delete ptr will actually cause a problem.
https://stackoverflow.com/questions/186237/program-only-crashes-as-release-build-how-to-debug points out —
- guard bytes on the stack frame– The debugger puts more on the stack, so you’re less likely to overwrite something important.
I had frequent experience reading/writing beyond an array limit.
https://stackoverflow.com/questions/312312/what-are-some-reasons-a-release-build-would-run-differently-than-a-debug-build?rq=1 points out —
- relative timing between operations is changed by debug build, leading to race conditions
Echoed on P260 [[art of concurrency]] which says (in theory) it’s possible to hit threading error with optimization and no such error without optimization, which represents a bug in the compiler.
P75 [[moving from c to c++]] hints that compiler optimization may lead to “critical bugs” but I don’t think so.
- poor use of assert can have side effect on debug build. Release build always turns off all assertions as the assertion failure messages are always unwelcome.