My first program was on a Vtech laptop for kids. It had a BASIC interpreter. The code required you to specify the lines (yes, good old times) and use the goto command to write loops.

Features
I am very impressed by the features:
- Use “CTRL+MouseClick” in the .tex file to see where the corresponding output in the PDF is. Conversely, you can use “CTRL+MouseClick” on the PDF to see where this output is generated in the .tex file.
- Auto completion via “TAB”. For example type “\sec” and TAB and it will complete it to “\section”
- A spell checker that ignores the LaTeX code: Go to Edit -> Spelling -> English
- LaTeX Error Hook: If you press the green button to create your PDF but you have errors in the .tex file, the green button will turn red.
Just click on the red button and a tab that only shows the errors will appear.

Installation
I discovered TeXworks after installing MiKTeX on Windows. MiKTeX is the LaTeX version for Windows. To install it proceed as follows:
1. Go to http://miktex.org/
2. On the left hand side click on “Download MiKTeX 2.9″. Choose for example “Basic MiKTeX 2.9 Installer” and start the download.
3. Install MiKTeX after the download. When it asks “Download packages on the fly” choose “Yes”.
4. After the installation has finished go to: Start -> All programs -> MiKTeX 2.9 -> TeXworks

If you already have MiKTeX but not TeXworks you can download TeXworks here: http://www.tug.org/texworks/

Before you start I recommend these settings for TeXworks:
- Activate the Syntax Highlighting by clicking on: Format -> Syntax Coloring -> LaTeX
- Show the line numbers by clicking on: Format -> Line Numbers
- Change the font size: Go to Edit -> Preferences -> Editor (and set the font size e.g. to 12 pt)

LaTeX tutorial
If you are completely new to LaTeX I recommend these documents with an emphasis on math symbols:
Getting Started with LaTeX, By David R. Wilkins
ArtOfProblemSolving LaTeX tutorial (it includes a tutorial on TexnicCenter, another LaTeX editor, but you can ignore that part)

Example:
Suppose today it’s Monday and you want to celebrate your birthday on Wednesday with an outdoor party. Of course, you are interested in the weather and you find this data:

If sunny today, then tommorow:
                   80% probability for sunny
                   20% probability for rainy

If rainy today, then tomorrow:
                   60% probability for sunny
                   40% probability for rainy

This data could for example have been collected during summer. Note that the weather tomorrow only depends on the weather from today, so e.g. it does not matter what the weather was a week ago. So today on Monday, you go outside and see that it is a rainy day. Therefore, the probability that it will be sunny tomorrow is 60%. The problem is that your birthday is not tomorrow but in two days on Wednesday. What is the probability then?

A good idea is to visualize the situation as a graph:

These are the ways to get from rainy(Monday) to sunny(Wednesday):
a) rainy(Monday) -> sunny(Tuesday) -> sunny(Wednesday)
b) rainy(Monday) -> rainy(Tuesday) -> sunny(Wednesday)

Let’s calculate the probability for a):

Transition rainy(Monday) -> sunny(Tueday): 0.6
Transition sunny(Tuesday) -> sunny(Wednesday): 0.8
=> Transition rainy(Monday) -> sunny(Tuesday) -> sunny(Wednesay): 0.6 * 0.8 = 0.48

Let’s calculate the probability for b):

Transition rainy(Monday) -> rainy(Tueday): 0.4
Transition rainy(Tuesday) -> sunny(Wednesday): 0.6
=> Transition rainy(Monday) -> rainy(Tuesday) -> sunny(Wednesay): 0.4 * 0.6 = 0.24

The total transition probability is therefore: 0.48 + 0.24 = 0.72
In a more formal notation:

p[rainy(Monday)->sunny(Wednesday)] 

= p[rainy(Monday)->sunny(Tuesday)->sunny(Wednesday)] + p[rainy(Monday)->rainy(Tuesday)->sunny(Wednesday)]

= p[rainy(Monday)->sunny(Tuesday)]*p[sunny(Tuesday)->sunny(Wednesday)] 
+ p[rainy(Monday)->rainy(Tuesday)]*p[rainy(Tuesday)->sunny(Wednesday)]

= 0.6*0.8 + 0.4*0.6 
= 0.48 + 0.24
= 0.72

We could ask other questions:
- What is the probability if we start with sunny(Monday)?
- What is the probability that it will rain on Friday?

It turns out that we can answer these questions easily if we introduce a transition matrix P:

p(ij) is the transition probability transition from i to j, e.g. p(sr) is the transition probability from sunny to rainy.
We have calculated the probability for rainy(Monday)->sunny(Wednesday) before. Let’s do this again with the transition matrix. To get the probability we just take the second power of P:

The probability for rainy(Monday)->sunny(Wednesday) is in the left bottom corner of the matrix. The value is 72% which is the same as we calculated before.
(Below is a figure of the matrix. The probability for rainy(Monday)->sunny(Wednesday) is the entry.)

To answer the other questions:
- What is the probability if we start with sunny(Monday), i.e. what is the probability for sunny(Monday)->sunny(Wednesday)?
Answer: Have a look at the top left corner value. The probability is 76%.

- What is the probability that it will rain on Friday, i.e. what is the probability for rainy(Monday)->sunny(Friday)
Answer: If we start on Monday we will have to wait four more days: Tuesday, Wednesday, Thursday and Friday. This corresponds to 4 transitions:
(i) Monday -> Tuesday
(ii) Tuesday -> Wednesday
(iii) Wednesday -> Thursday
(iv) Thursday -> Friday
Thus, calculate and look for the entry.

Finally, here is the definition of a Markov chain (quoted from reference [3]):

A (finite) Markov chain is a process with a finite number of states (or outcomes, or events) in which
the probability of being in a particular state at step n+1 depends only on the state occupied at
step n.

Exercises:
a) What is the probability for sunny(Monday)->sunny(Tuesday)
b) What is the probability for sunny(Monday)->rainy(Wednesday)?
c) Have a look at and . Where do you recognize that the sum of the probabilities equals 1.
d) How do you calculate the probability for rainy(Monday)->rainy(Thursday)?
e) Can you explain why the formalism with the transition matrix works? (Hint: Look at reference [2])

Answers:
a) The probability for sunny(Monday)->sunny(Tuesday) is P(ss) = 0.8.
b) The probability for sunny(Monday)->rainy(Wednesday) is
c) The probabilities in a row add to 1: the final weather is either sunny or rainy.
d) If it is Monday we will have to wait 3 days till Thursday: Tuesday, Wednesday and Thursday.
This corresponds to 3 transitions:
(i) Monday -> Tuesday
(ii) Tuesday -> Wednesday
(iii) Wednesday -> Thursday
Calculate and consider the entry.

e) To see why the formalism with the transition matrix works consider again our first example.
We wanted to know the probability p[rainy(Monday)->sunny(Wednesday)] and we found out that there are two paths corresponding to two probabilities:

(i) p[rainy(Monday)->sunny(Tuesday)->sunny(Wednesday)] 
(ii) p[rainy(Monday)->rainy(Tuesday)->sunny(Wednesday)]

(i) p[rainy(Monday)->sunny(Tuesday)]*p[sunny(Tuesday)->sunny(Wednesday)] = p(rs)*p(ss)
(ii) p[rainy(Monday)->rainy(Tuesday)]*p[rainy(Tuesday)->sunny(Wednesday)] = p(rr)*p(rs)

p[rainy(Monday)->sunny(Wednesday)] = p(rs)*p(ss) + p(rr)*p(rs)

Now, I will rename the weather states as 1 and 2:
1 stands for sunny
2 stands for rainy

p[2(Monday)->1(Wednesday)] = p(21)*p(11) + p(22)*p(21)

In general, if we have an initial state i and a final state j we can write:

p[i(Monday)->j(Wednesday)] = p(i1)*p(1j) + p(i2)*p(2j)

This should remind you of a matrix multiplication:
Let C = A*B where A,B and C are matrices. Then the matrix multiplication is:

References:
[1] Introduction to Markov Chains – Part 1
Introduction to Markov Chains, Part 2
A youtube video by patrickJMT.

[2] Introduction to Probability (pdf)
A book on probability theory by Charles GRINSTEAD and J. Laurie SNELL (see Chapter 11).

[3] Markov Chains (pdf)
Lecture notes by Warren Weckesser, Colgate University.

The complete list of talks can be found here: TedxCaltech: Feynman’s Vision, the next 50 years

1. Strange behavior?

Let’s have a look at the following Python code:

def changeList1(x):
    x.append(41)

def changeList2(x):
    x = [41,42]

Save the code in a file callBySharing.py and run it in the Python-Shell (if you use IDLE press F5; if you use a terminal use python -i callBySharing.py). Type the following in the Python-Shell:

>>> myList = [1,2,3]
>>> changeList1(myList)
>>> print(myList)
[1, 2, 3, 41]

- In line 1 we define a list.
- In line 2 we passed the list to the function changeList1(). If you look at the definition of changeList1() you will recognize that it tries to append the value 41 to the list.
- In line 3 we print the list and see that the value 41 indeed is appended to the list.
- As the name of the function changeList1() suggests we have been successful in changing the list.

Now, continue in the Python-Shell:

>>> yourList = [5,6,7]
>>> changeList2(yourList)
>>> print(yourList)
[5, 6, 7]
>>>

- In line 1 we create a list.
- In line 2 we pass the list to the function changeList2(). If you look at the definition of changeList2() it seems that it tries to change the list to [41,42].
- In line 3 we print the list and see that it has not changed.

2. Analyzing the functions

So, why did changeList1() modify the list and changeList2() not? To understand this let’s write the functions in another way. We will introduce a refCopy variable that illustrates a copy procedure (which is not visible).

def changeList1b(ref):
    refCopy = ref
    refCopy.append(41)

def changeList2b(ref):
    refCopy = ref
    refCopy = [41,42]

Add the code to the file callBySharing.py and run it again in the Python-Shell. Then type the following in the Python-Shell:

>>> myList = [1,2,3]
>>> changeList1b(myList)
>>> print(myList)
[1, 2, 3, 41]
>>>
>>> yourList = [5,6,7]
>>> changeList2b(yourList)
>>> print(yourList)
[5, 6, 7]
>>>

- In line 01-04 we used changeList1b() and were successful in modifying the list.
- In line 06-09 we used changeList2b() and were not successful in modifying the list.
So, we have the same behaviour as before but the new functions make it easier to see what is going on.

Let’s analyze the function changeList1b() by having a look at its definition:
- In line 1 we define its name.
- In line 2 we define refCopy = ref. Keep in mind that a reference is just something that contains a memory address of an object. For example, in the figure below the value of ref is the address of the object [1,2,3]. The address could be 49838280. With refCopy = ref we copy the address 49838280 and assign it to refCopy. In the figure you can see the result: we now have two references pointing to the same object, namely [1,2,3]. This is also known as object sharing since both references, ref and refCopy, share the same object.
- In line 3 we write refCopy.append(41). This just means the following: On the right hand side we have the value 41 and try to append this value to the object that refCopy is pointing to. We know from the figure below that refCopy is pointing to the list [1,2,3], therefore 41 is appended.

Now, let’s analyze the function changeList2b() by having a look at its definition:
- In line 5 we define its name.
- In line 6 we write refCopy = ref, i.e. we copy the value of ref and assign it to refCopy. For example, the address of ref is 43857600 which is then assigned to refCopy.
- In line 7 we write refCopy = [41,42]. On the right hand side we create a new object [41,42]. With refCopy = [41,42] we tell refCopy to point to this new object, i.e. the value of refCopy is not 43857600 anymore (this is the crucial point!). The new value of refCopy is the address of the object [41,42] which is 43932368 (see figure below).
As you can see in the figure below, the reference yourList still points to [5,6,7].

We saw that the value of a reference (an address) is copied. This is known as call by object reference or call by sharing.

3. An exercise
Let’s write a third version of the function:

def changeList3(x):
    x+=[2012,2013]  # append two values to the list

Solution:
a) Save the code for changeList3() in the file callBySharing.py. Then, type the following in the Python-Shell:

>>> myList = [1,2,3]
>>> changeList3(myList)
>>> print(myList)
[1, 2, 3, 2012, 2013]

b) This is a drawing of the references and objects. The address is made up.
Note: Although there is no refCopy in the definition of changeList3() you can imagine that the computer uses this. It’s just not visible to us.

4. Immutable objects – Strings and Numbers
Let’s try to change a string in a similar manner as changeList3():

def changeString(x):
    x+='World!'     # try to append 'World!' to the string

Save this function in the file callBySharing.py and run it in the Python-Shell. Then type the following in the Python-Shell:

>>> myString = 'Hello'
>>> changeString(myString)
>>> print(myString)
Hello

- In line 1 we created a reference myString to the object ‘Hello’.
- In line 2 we pass myString to the function changeString(). From the definition of the function changeString() we hope that ‘World’ is appended.
- In line 3 we print myString but we see in line 4 that ‘World’ is not appended.

Although we did the same thing as in changeList3() we still couldn’t change the object ‘Hello’. The reason is that strings are immutable objects, i.e. you can’t change the object.

——

In Python everything is an object, even simple things like integers. You can confirm this by typing the following in the Python-Shell:

>>> b = 42
>>> print(id(b))
505498648
>>> b = 99
>>> print(id(b))
505499560

- In line 1 we have a reference b that points to the object with value 42.
- In line 2 we check the address of the object that b is pointing to. It is 505498648.
- In line 3 we create a new object with value 99. With b = 99 the reference points now to this new object.
- In line 4 we check the address of the object b is pointing to. We see that the address is now 505499560.

Now, similarly to changeList3() we try to modify a number:

def changeNum(x):
    x+=3       # try to increase x by 3

Save this function in the file callBySharing.py and run it in the Python-Shell. Then type the following in the Python-Shell:

>>> myNumber = 77
>>> changeNum(myNumber)
>>> print(myNumber)
77

Line 4 shows that the object 77 is not changed. This is because numbers are immutable objects.

References: (no pun intended)
1. Parameter Passing
This article is part of an online Python couse.

2. Python: How do I pass a variable by reference?
This is a discussion on stackoverflow.com.

3. Is Java pass by reference?
This is a nice discussion on call by object reference, and although it is on Java the same applies to Python. I found two posts particularly helpful: post1 and post2.

11) Nonlocal correlations between the Canary Islands
This is an excellent blogpost on the blog BackReaction. It discusses the role of nonlocality in Bell’s theorem, in particular the locality loophole and the freedom-of-choice loophole.
Prerequisite: Understanding of light cones. Here are some practice questions on light cones.

12) Is the moon there when nobody looks? Reality and the quantum theory
This is a very intuitive article by David Mermin. He introduces machines that have 3 settings and two lamps (red and green) and shows that assigning 3 “real” properties to particles results in a contradiction.

13) Spooky Actions At A Distance?: Oppenheimer Lecture
A lecture by David Mermin on EPR and Bell’s theorem. Here, he uses three entangled particles (see Greenberger–Horne–Zeilinger state) instead of two. I recommend watching this lecture after you have read 12).

14) Bertlmann’s socks and the nature of reality
by John Stewart Bell
Here, John Bell derives the d’Espagnat inequality by considering socks that may or may not survive one thousand washing cycles at 45°C, 90°C and 90°C.

The d’Espagnat inequality is: N(A,notB)+N(B,notC)≥N(A,notC)
Bell mentions that this is trivial: Each member in N(A,notC) on the right hand side either doesn’t have property B and therefore is in N(A,notB) or has property B and therefore is in N(B,notC). Thus, the left hand side cannot be less than the right hand side, in other words the left hand side is greater or equal than the right hand side.
Note: When you read the document don’t wonder about the figures. They are not missing but shown in the end.
By the way, Reinhold Bertlmann was a colleague of John Bell at CERN. He is a professor now and still seems to wear differently coloured socks.
Bell’s original paper (see DrChinese’s site) becomes much more understandable with this document.

15) Part 1 – From Bell’s Inequalities to Entangled Qubits: A New Quantum Age?
This is a talk by Alain Aspect who conducted some experiments on Bell’s theorem. There are five parts.

16) Hidden variable – Derivation of line
In his talk Alain Aspect shows that one can construct a hidden variable theory that predicts a line for the expectation value. An easy to follow derivation can be found in Quantum theory: concepts and methods by Asher Peres on page 161-162.

Advice from Marissa Mayer:

1. Find something you are really passionate about.

2. “It’s not what Zoon knows but how Zoon thinks”
Knowledge is not as important as the ability to view things in a different way.
Become a good problem solver instead of a memorizer.

3. Find the smartest people you can and surround yourself with them.

4. Find allies rather than adorers.

5. Find the courage to do things you are not ready to do.

6. Find places where you are comfortable.

7. Help other find things. Be an information foundtain.

After having watched the video above one of the youtube commenters posted something interesting:

I must not fear.
Fear is the mind-killer.
Fear is the little-death that brings total obliteration.
I will face my fear.
I will permit it to pass over me and through me.
And when it has gone past I will turn the inner eye to see its path.
Where the fear has gone there will be nothing.
Only I will remain.

I looked it up and found out that it’s from Dune, also known as Litany against Fear.

Eclipse is a wonderful IDE known to Java users. I like it because of its auto-completion feature, e.g. if you use the dot operator on an object, Eclipse will show you the available methods. You can use Python in Eclipse by installing PyDev. To install PyDev follow the instructions here: Installing PyDev Manual. Or watch this youtube video.

1. Create a project (follow the instructions there)
2. Create a module (follow the instructions there)
3. In example.py paste the following code:

class Airplane:
    __fuel = 0
    maxFuel = 24000
    
    def addFuel(self, volume):
        if(self.__fuel + volume <= 24000):
            self.__fuel = self.__fuel + volume
        else:
            print("Error: You are adding too much fuel!")
            print("Fuelling not possible!")
        self.__printStatus()

    def __printStatus(self):
        print("Current fuel:", self.__fuel)

So, add the following to example.py (add lines 17-22):

class Airplane:
    __fuel = 0
    maxFuel = 24000
    
    def addFuel(self, volume):
        if(self.__fuel + volume <= 24000):
            self.__fuel = self.__fuel + volume
        else:
            print("Error: You are adding too much fuel!")
            print("Fuelling not possible!")
        self.__printStatus()

    def __printStatus(self):
        print("Current fuel:", self.__fuel)


def myProgram():
    airbus = Airplane()
    airbus.addFuel(20000)
    
if __name__ == '__main__':
    myProgram()

Current fuel: 20000

Note:
There is also an auto-completion in IDLE. You can test it in IDLE by running the aircraft.py module from last time in the Python-Shell (use F5). Then type the following in the Python-Shell:

>>> a = Airplane()
>>> a.

>>> a.addFuel(

Note2:
The only thing that I miss in PyDev/Eclipse is running a file (e.g. example.py or aircraft.py) in a Python-Shell. In IDLE you can simply press F5. However, in PyDev I have not yet discovered such a feature (in case I missed the feature let me know).

References:
Official PyDev Getting Started Guide