However, this is an excellent opportunity to do something else exciting, find another good job, maybe move somewhere interesting, and work on a new and interesting product.

I am sure the company had trouble with an interesting but troubling dilemma: how to reduce costs without sacrificing the ability to produce the products the company needs to make sales. I am not sure if reducing their development force was really the best idea; who will build the new products and features they need to make sales?

I wish them best of luck in their endeavors, and hope things go well for them. As for me,  it is time to, in the words of Mark Twain, “…throw off the bowlines. Sail away from the safe harbor. Catch the trade winds in your sails. Explore. Dream. Discover.”

a = []
h = {:a=”a”}
a << h
h[:a] = “b”
a << h
h[:a] = ‘c”
a << h

What will the array contain? Interestingly, it will contain [{:a=>"c"}, {:a=>"c"}, {:a=>"c"}].

This shows that appending the hash into the array is by reference.

When I had to do something like this I used this very simple work around:

a = []
h = {:a=”a”}
a << Hash[h]
h[:a] = “b”
a << Hash[h]
h[:a] = ‘c”
a << Hash[h]

This causes a new hash to be created and assigned with each append.

Symptoms: You build a project in Visual Studio, set a breakpoint, and execute. However, the breakpoint immediately disappears (completely – not just temporarily disabled), and a breakpoint appears somewhere else. If execution stops on the new breakpoint, examination of the call stack might show that the function in which execution stopped was in fact called, or it might show that instead the function with the original breakpoint was called, or it might even show that a third function was called. If you go up one level in the call stack, and examine the disassembled code, you might see code to call the function in which execution stopped, or you might see code to call the function with the original breakpoint, or you might even see code to call a third function.

Explanation by Way of Demonstration:

Here’s a fun little demonstration of how to get yourself into trouble by optimizing a debug build, even when you don’t realize you’re optimizing. This demonstration works for me in Visual Studio 2008. There is possibly some element of randomness in some choices made by the compiler to cause this, so it might not work in other versions of VS, and it might not even work all the time in VS 2008.

Create a project. Make it a console project. Set these configuration settings for the debug build:
[C/C++].[General].[Debug Information Format] to “Program Database (/Zi)”.
[C/C++].[Code Generation].[Enable Function-Level Linking] to “Yes (/Gm)”.
[Linker].[Debugging].[Generate Map File] to “Yes (/MAP)”.
[Linker].[Optimization].[EnableCOMDAT Folding] = “Remove Redundant COMDATs (/OPT:ICF)”

Note that the problem will occur EVEN IF you disable optimization by setting [C/C++].[Optimization].[Optimization] to “Disabled (/Od)”.

Replace the contents of the main cpp file with this:
#include “stdafx.h”

void ambulate() {
}

class CJumper {
public:
CJumper() : m_NumberOfJumps(0) {}
void jump();
int m_NumberOfJumps;
} Jumper;

void CJumper::jump() {
ambulate();
++m_NumberOfJumps;
}

class CSkipper {
public:
CSkipper() : m_NumberOfSkips(0) {}
void skip();
int m_NumberOfSkips;
} Skipper;

void CSkipper::skip() {
ambulate();
++m_NumberOfSkips;
}

class CHopper {
public:
CHopper() : m_NumberOfHops(0) {}
void hop();
int m_NumberOfHops;
} Hopper;

void CHopper::hop() {
ambulate();
++m_NumberOfHops;
}

int _tmain(int argc, _TCHAR* argv[]) {
Skipper.skip();
return 0;
}

Put a breakpoint on any line of skip().

Build and execute the debug version.

Amazingly, the breakpoint on hop will disappear, and a breakpoint will magically appear on skip, and execution will stop there. But looking at the call stack or the disassembled code, you will see that jump() was called!!!

When COMDAT Folding is enabled, the linker will notice that each function has exactly the same code, so it will make only one function which will be called in all three instances. Unfortunately, this totally confuses the debugger.

Take a look at the addresses of hop, skip, and jump in the map file. They are all the same.

“But they DON’T all do the same thing,” I can hear you say. “One of them increments a member of CJumper, one increments a member of CSkipper, and the third increments a member of CHopper.”

‘Tis true, but what does that look like at the machine level? In each case, a call to the function consists of passing into the function a pointer (the “this” pointer), which the function will use as a pointer to an integer to be incremented. So they really ARE exactly the same.

Now insert:
int m_NotUsed;
immediately before the declaration of m_NumberOfSkips. Build and execute. This time, it works as expected, hitting the breakpoint in skip(). This happens because now skip is different than the other functions. Instead of incrementing the integer pointed to by its argument, it increments the next integer. So, the linker can no longer have one function to represent all three apparent functions.

While moving some wood out to the trash pile (I do some of my best thinking while doing physical work), I had an interesting thought. The Dreyfus model does work well in modeling the acquisition of skill in a given subject, and can be nicely expanded on. Specifically, it can be used to model the acquisition of general skill. As you acquire skill in any given subject, you acquire a sort of understanding of the way skill works in general – unconsciously or, with meta-cognition, very consciously – and can move up through the levels of understanding much more quickly in other subjects. In fact you can, through certain types of exercises in meta-cognition, acquire this skill even faster. I suppose we could call it meta-skill.
I think perhaps the most important thing you must do to acquire this meta-skill is to decompartmentalize your mind; you must learn to connect each of your experiences with the rest, not thinking about something in isolation. Sometimes you have to think about something in isolation, but it needs to be a conscious, temporary thing. After all, if your experiences are disconnected in your mind, how can one field you possess skill in help you acquire skill in another?

The idea of decompartmentalization in meta-cognition is extremely important in even a single field. Take, for example, my primary field: software engineering. To simply believe that understanding syntax and a few maxims like “write lots of comments” will give you the ability to be a good software engineer is laughable. However, this is how many students – and even some professionals – view things. They ignore the complex and vital relationships between mathematics and programming for instance. Things get even worse when they start to try to work in a problem domain that they are not used to; they have no idea how to apply programming to the problem! It’s alright to start out like this – the novice level of the Dreyfus model – but one needs to move past it to become more skilled.

Fun? Well, you are getting the opportunity to talk about the thing you love, programming. And if you don’t love programming, why are you interviewing for a programming job? And when the interviewers ask technical question you get to solve a cool puzzle (assuming the interviewer is good). Plus, you get to brag about your accomplishments, and chat about your experiences. How often do you get to this, except when showing vacation pictures to captive family members?

As for learning, the whole thing is rife with possibilities. When they ask a questions you don’t know the answer too, that just means there is one more cool thing to learn about that is also important to prospective employers. If you can get them to describe it to you, you immediately get to learn about it, and can perhaps impress the interviewers if you grasp the concepts quickly enough.
For example, at my last interview the RAII (Resource Acquisition Is Initialization) idiom was brought up. I feel pretty dumb for not knowing about it, since it is such a simple idea, but I got it pretty quick when it was explained. It is very valuable, and I have read more on it now, and am very glad for it.

Why wouldn’t you get a kick out of getting to do this?

The biggest reason for avoiding globals is that it makes it so any function can change them at any time, making it harder to trace execution and debug programs. However, sometimes avoiding them requires passing around a lot of arguments that can increase complexity and reduce understanding much worse than having them! This is especially the case if a function has to accept an argument just because a function that is called by a function that it calls needs it! We don’t always need to do this, and in those cases globals should be avoided like the plague; they should not be used just so you don’t have to be disciplined in argument passing.

However, in those cases where an object/variable is truly needed in a global scope, such as the console in an OS kernel, passing it around would be a nightmare. In these cases globals are something to be used, cautiously.

In the case of global objects in C++, another problem rears its ugly head: order of initialization. When a program is run, all globals are initialized, usually by functions provided by the standard library, or by you in kernels and low level code. The problem is that the order of initialization is undefined. When the program starts, every global object address is considered valid, but has not been initialized. If one object tries to use an uninitialized object in construction, there’s a problem, and it’s usually a run time error. To prevent this, we can use global object functions, like so:

Foo& getGlobalFoo() {
static Foo g_foo;
return f_foo;
}

The first time the function is called the object is created and initialized. Because it is declared static, it is only created once and the same instance is used through the whole program. The best part is that we don’t need to worry about initialization order at all; the function calls will cascade down, creating each function as needed. In a fast response system we may not want this, so then we can call each one, in the correct order, on entering main (or wherever makes sense).

Now, the basics can be done by linking largely the same way as for C, but important features (such as virtual functions!) require more work. Worse yet, there is very little documentation of the subject.

It took me a couple hours of stepping through assembly while watching registers, as well as reading through some LD scripts, but I finally figured out some of the problems.

1. Virtual functions: A virtual function call through a pointer in C++ requires a vtable lookup. This vtable is compiled (at least in GCC) with a linkonce.t label. If LD does not find a reference to this in its script, it will simply toss the whole section and continue as if nothing happened! So, we have to tell LD where to put it, as such:

.text phys : AT(phys) {
code = .;
*(.text)
*(.gnu.linkonce.t.*)
*(.gnu.linkonce.r.*)
*(.rodata)
. = ALIGN(4096);
}

2. Above is also a linkonce.r label. This is used, (possibly for other things as well?) for member functions defined in the class body. Same problem of non-inclusion if not expressly linked.

A good source for information, but far from complete, is: http://wiki.osdev.org/C_PlusPlus

There they discuss some important issues, such as global objects (see my next post!), pure virtual functions, etc.

Well, the big problem is that the system dies when any attempt is made to do an indirect virtual function call; that is, any call to a virtual function through a pointer instead of an object. I have been using the free version of the IDA disassembler to examine to fully linked executable. The full version is over $400, but even the free version is nice!

The best idea I have come up with yet is that the vtable is somehow not being initialized or even allocated. The best indication of this is that when the vtable reference is made the address of the function is supposed to be in the eax register, at least with the compiler and architecture I am using. The problem is that it is not! By the time the function is called, eax contains 0×0, which is quite bad.

I am to design and implement the machine problems (projects) for the senior level operating system class here at A&M. The professor in charge of the class asked me to do this because he does not have the time, and does not get a TA early enough; especially since it will take a couple months. He wants it to be designed in an extremely modular fashion, so the students can take out a module and replace it with their own. I will implement these modules (such as paging management, non-blocking keyboard I/O, etc.) with naive algorithms and techniques. The students will be assigned to remove my module and code in their own, using appropriate algorithms. This has some pretty nifty benefits:  the students will have a largely working operating system in which to test their algorithms; the professor can pick and choose which aspects of the OS he wants to teach; and the simple design will allow the students to learn from the whole system, not just the assigned parts.

To allow this modularity the professor would like me to build the OS in C++. I am not completely convinced this can be done well, but I have some ideas and am certainly going to try. I am currently learning the about the C++ object model implementation so that I can work with it to get the results I need.

I think if I lived there, I would want to live West of Denver, maybe South-West, and drive into work. My top interest in a job right now is Lockheed Martin in Denver. They are a great company, I could work there I would love on exciting projects, live in a beautiful place, and I could hopefully even work at the space systems company, my greatest interest of all.