Here is another rather personal update.

So, I spent the last year in the poorest parts of South America. Just me, my math books, and 3rd world living. The highland towns of Bolivia are the ones I remember best. No hot water, no heating, sleeping with all my clothes on at the same time. The narrow broken mountain roads, the speed crazy coca chewing bus drivers, all those rickety 16 hour bus journeys. Eating every day at the town markets, sitting next to short and stocky native indians. Two dollars a night for a room, two for food, two for beer and two for internet. A simple but free life. A year of studying.

And then my money ran out. So I’m back in the UK. I found a job in Basingstoke. Its a C++ job. Its traditional software development (as opposed to 24/7 web service plumbing) just like I wanted . The hours are 9to5 and the pace is quite relaxed. The pay is good. There is some maths in there as well. This looks like the best job I have had so far. In my previous jobs I always ended up working 10 hour days. I dont want that again. There is more to life than work. I think now I will have time to study and enjoy my free time a little. I also went to a couple of interviews for investment banking jobs, but backed away when I realized it was exactly the type of job I didn’t want. I have had enough of maintaining large fragile legacy 24/7 systems. I can do without those 3AM support calls, thank you. I’m happy I did not end up in Games either. Long hours, low pay and tight deadlines. No thanks.

I’m reading a book now called “The C++ FAQ 2nd edition” by  Marshall Cline. I would not have picked it up where it not for some stranger on reddit that recommended it. Its surprisingly good considering its over 10 years old.  You feel the age a bit by the OOP buzz wording. However, there is stuff in here that I have not read elsewhere. For instance, inheritance is not about the IS-A relationships or sub-typing. Public inheritance is about substitutability, nothing more or nothing less. For instance, even though a circle is a subgroup of the group oval in the mathematical sense. Their interfaces probably still wont be substitutable. This is not a book for beginners though, its more of a “Best Practices” type book. I recommend it.



Maths is Neat!

March 12, 2010

Wow, its been over a year since I posted anything here. This blog was meant to be only about C++ but that might change now. Two interesting books where published last year that I did not have time to read. They where Stroustrups new book “Programming: Principles and Practice Using C++” and Stepanovs “Elements of Programming”. The first is aimed at C++ beginners, the second at Mathematicians. Stepanov is the genius that invented STL.

That brings me to the point of this post. I always wanted to learn more maths but somehow never got around to studying it seriously. There was always something else. As a programmer you can make a career without any maths knowledge at all. I would guess 95% of programming jobs don’t require any maths. But then again 95% of programming jobs are quite boring. Its seems to me all the interesting programming is in maths heavy areas. For instance 3D programming is heavy with linear algebra, physics simulation is heavy with calculus. Algorithm and data structure design is also heavy with maths. That all interesting stuff.

So I bought a bunch of math book, put them in my backpack. Quit my job. Bought a one way ticket to South America. And for the  last year I have been living cheaply and studying hard. Who needs schools and teachers when you can teach yourself anything. It might sound crazy but its been great. I started studying pre-calculus, all that stuff I once knew and forgot. I moved on to study lots of linear algebra. I have also been studying a bit of calculus and about the math in games. I have also had time for sum fun and games, im in South America after all. By summer time I’ll be job hunting for a programming job that requires some of this math. I’ll try getting a 3D game programming job. I think that would be very interesting. My plan B is to go back to University and study maths. This stuff is interesting in its own right. I got nothing but respect and admiration for mathematicians and what they can do. Mathematics is the language of the universe after all. And what could be more interesting than that?

Maths is just great, especially in connection with programming. I hope I keep motivated to keep studying this for years to come.


The most interesting explanation of rvalue references yet:

Want to know whats the need for the std::move method? As I understand it, It’s needed because as soon as you give an rvalue reference a name it “becomes” an lvalue reference! This is probably done to make it harder for you to shoot yourself in the foot (as you would not want to use the name of a rvalue reference after its rvalue had already been moved away and the rvalue reference name was invalidated). So there needs to be a way to get back to an  rvalue reference from an lvalue somehow . That is what the move function is all about. std::move()simply converts any rvalue or lvalue to an rvalue reference, by stripping away its name.

Another look at Peterson

December 6, 2008

I had another read of Bartosz Milewski recent blog post about the different memory orderings of c++0x.

The most interesting thing about the blog post (that I missed last time) was actually the proposed Peterson locking algortithm that used some none default c++0x  memory orderings for the stores and loads of its atomic variables. It turns out that his proposed implementation is broken. Yupp, that’s right, even some of the experts on concurrency can get lost when straying from the straight and narrow road of  default sequential memory ordering. Exactly why the implementation is broken, and another implementation that actually works (by Dmitriy V’jukov) , is explained (or even proven) on Anthony Williams blog.

Anthony’s blog post was a very informative read. I probably read it ten times until I (think I) understood why one implementation was broken and the other wasnt. Lots of “ahaa – no wait a minute – oh OK, I think I see what you did there” moments. Reasoning about concurrency is allot like pealing an onion, there is always another layer underneath that you didn’t know about. 

(The problem as I understand it, was that the atomic variable “victim” was read and written by both threads,  and one needed to make sure that the writes that happen before on the first  thread where synchronized to the the reads that happen after on the second thread. Because the memory ordering for the write on the first thread was release only, and the read on the second thread was acquire only, the second thread could read an old value from it invalid cached even though the variable had been overwritten by the the first thread.)

Writing correct concurrent code is an interesting but complex task, and anyone claiming different are probably writing broken code but dont realize. If guess the thing to take from all this is that unless you can prove that its Okay to use a more relaxed memory model than the sequential consistent one, you really shouldn’t.

Here is a short description of the different memory ordering for concurrency in C++0x; Bartosz Milewski’s blogs port about C++ atomics and memory ordering.

The default for atomic variables is the familiar sequential ordering (memory_order_seq_cst), its also the slowest as it inserts lots of most memory fences that prohibit the CPU from reordering code as it sees fit. Between that and no ordering (memory_order_relaxed), there are also ordering that just insert fences on reads (memory_order_acquire), on writes (memory_order_release), and on both read and write (memory_order_acq_rel). Being able to choose a memory order other than the safe and slower default is a nice feature, and corresponds well with the C++ deign rationale of not having to pay for what you don’t use. The java volatile’s apparently works much like the c++0x atomic’s with the default sequential ordering, except java volatile’s are not atomic (there is a java library for that).

Herb Sutter posted an excellent new effective concurrency article; Measuring Parallel Performance: Optimizing a Concurrent Queue. Its surprising to see how much scalability can be gained by wasting space on padding, to make sure independent variables get to live on different cache lines.

Boost threads shows the way

December 2, 2008

What’s New in Boost Threads? Boost threads moves closer to C++0x. The interface looks nice. Threads and locks are now movable (can be stored and sorted in move aware containers). Thread’s constructor can bind the  functions arguments to the function. Lock can now lock multiples mutexes at once to avoid deadlocking (when succeeding to get one lock, but failing getting the other).

Also, here is a link to Anthony Williams blog (the author of boost threads and the upcoming C++ Concurrency in Action book).