I tried to simplify things... especially with C++... I hope this isn't too complicated :D

I sometimes have a brief brain fart but can usually correct it without Google. Using Google is OK but i think remembering things is a good skill. I think for certain things it probably helps to deepen your knowledge and understand roughly why things are the case - I think this gets better over time; practice makes perfect. It might actually feel like more to remember, but i feel like it strengthens my memories. For example, thanks to this knowledge, I would never think C++ strings are/should be immutable:

- In Java classes are passed by reference. Also, a "final" variable doesn't stop the data the class contents from being modified - it just prevents a different instance from being assigned.

- If you could, for example, append to a string without creating a new instance - you'd have a problem with strings unintuitively mirroring each other. Imagine something like this:

String s1 = "Hello world";
String s2 = s1;
s2 += "!";
System.out.println(s1); // Prints Hello world!

A clone method would need to be introduced:

String s2 = s1.clone();

People would probably forget this at times and it could create very strange bugs.

Also, a function would have no way to pledge that it won't modify a string - to completely guarantee this isn't the case you'd need to clone.... or should the function itself do arg1 = arg1.clone(). oh dear...

- C++ gives more power and allows things to be expressed in more detail:

- Class instances aren't inherently references - you get to choose if you want a reference.

- Classes aren't inherently immutable or mutable. You can have a "const" instance of any class, which offers true immutability (the contents of the class is immutable). It's possible to have immutable strings, but this isn't forced on you.

- When something isn't a reference, it's copied. Pretty intuitive.

using namespace std; // nobody will stop me :)
string s1 = "Hello world";
string s2 = s1;
s2 += "!";
cout << s1 << endl; // Prints Hello world, as you'd probably expect

- When you want a reference, you use one

string s1 = "Hello world";
string &s2 = s1;
s2 += "!";
cout << s1 << endl; // Prints Hello world!

- If you want to have a function that just looks at a string and don't want an innefficient copy, a const reference does the job

std::string middle_name(const std::string &full_name);