theory

I have recently read an article which stated that using \n is preferable to using std::endl because endl also flushes the stream. But when I looked for a bit more information on the topic I found a site which stated: If you are in a situation where you have to avoid buffering, you can use std::endl instead of ‘\n’ Now here comes my question: In which situation is it preferable not to write to the buffer? Because I only saw advantages of that technique. Isn't it also safer to write to the buffer? Because it is smaller than a hard drive it will get overwritten faster than data that is stored on

I have 2 new questions: 1) Consider this line: NSString *myString = [[NSString alloc] initWithString: @"Value"]; There were two things I learned, but I would like confirmation: As I learned, the "alloc" message indicates that the instance of NSString will be stored in the "heap" memory. I understood also that primitive variables such as "chars" are stored in the "stack" memory. Does this mean that: the instance of NSString is stored in the heap memory; AND that this object has an iVar pointer (when the initWithString method was called) to the "Value" string of primitive "chars", which reside

It doesn't matter if you're building an eshop or any other application which uses session to store some data between requests. If you don't want to annoy the user by requiring him to register, you need to allow him to do certain tasks anonymously when possible (user really have to have a reason for registering). There comes a problem - if user decides to login with his existing profile, he may already have some data in his "anonymous" session. What are the best practices of merging these data? I'm guessing the application should merge it automatically where possible or let the user decide

I understand what it means to access memory such that it is aligned but I don’t understand why this is necessary. For instance, why can I access a single byte from an address 0x…1 but I cannot access a half word (two bytes) from the same address. Again, I understand that if you have an address A and an object of size s that the access is aligned if A mod s = 0 . But I just don’t understand why this is important at the hardware level. Hardware is complex; this is a simplified explanation. A typical modern computer might have a 32-bit data bus. This means that any fetch that the CPU needs to do

I'm going through a phase of trying to avoid temporary variables and over-use of conditional where I can use a more fluid style of coding. I've taken a great liking to using #tap in places where I want to get the value I need to return, but do something with it before I return it. def fluid_method something_complicated(a, b, c).tap do |obj| obj.update(:x => y) end end Vs. the procedural: def non_fluid_method obj = something_complicated(a, b, c) obj.update(:x => y) obj # <= I don't like this, if it's avoidable end Obviously the above examples are simple, but this is a pretty common coding style

What are some examples where Big-O notation[1] fails in practice? That is to say: when will the Big-O running time of algorithms predict algorithm A to be faster than algorithm B, yet in practice algorithm B is faster when you run it? Slightly broader: when do theoretical predictions about algorithm performance mismatch observed running times? A non-Big-O prediction might be based on the average/expected number of rotations in a search tree, or the number of comparisons in a sorting algorithm, expressed as a factor times the number of elements. Clarification : Despite what some of the answers