Visual Studio 2010 worked fine at the beginning, but one day, suddenly, breakpoints stopped working. A yellow exclamation mark symbol was shown over them and placing the mouse cursor over such symbols showed the message “Breakpoint won’t be hit”.

Searching on the internet for this problem I found out it was a common one in almost every version of Visual Studio, specially in 2008 and 2010. Most common causes for this error are:

• The project was compiled in Release mode, not in Debug one
• Debug symbols are not found (or wrong path)
• Incremental Debug linking option is not enabled
• Not having installed the latest service packs and patches (some of them address this problem)
• Corrupted installation: Reinstalling the application, restoring default configuration or even deleting Registry Keys and Local App configuration stored in the Windows User profile folders might fix this case

The fact was none of the above worked for me, but found out that if I started Visual Studio with a different user account everything worked like a charm. After opening two projects (each generated with a different user) and compared differences on the .vproj XML files I found these extra lines added to the “faulty” one:

Removing these lines from the .vproj file and recompiling made the breakpoints to work again! The case was these lines referenced User configurations that didn’t appear in my VS configuration panels or couldn’t change (some of them were grayed). These XML lines contain a conditional inclusion and the path is $(UserRootDir)\MicrosoftCpp.$(Platform). It happened that path was C:\Users\Boriel\AppData\Local\Microsoft\MSBuild\v4.0, which was not the Visual Studio configuration Folder. Deleting it fixed the issue (it’s regenerated the next time Visual Studio IDE is started).

To avoid even more troubles I not only removed that folder, but also the local configuration stored in my profile (C:\Users\Boriel\AppData\Local\Microsoft\VisualStudio\10.0) and related registry keys (HKEY_CURRENT_USER\Software\Microsoft\VSCommon\10.0). Afterwards I restarted the IDE and a splashscreen warning told me the application was being prepared to be used for the first time. And the problem was gone.

An ant starts walking from vertex #1 and changes it direction at random on each vertex (might even turn back from the same edge it came from). Vertex #7 and #8 are poisoned. If the ant happens to walk into one of them it will die. The challenge consist in find out the probabilities of the ant dying or not and in which vertex (#7 or #8) when it does.

This program uses the previous one (which already defines a Graph class) to make a simple statistical simulation of the problem and give you an answer of what to expect. Obviously, the result by itself is not the entire solution: you also have to give a theoretical demonstration of such result

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vim:ts=4:et:sw=4:

from random import choice
from grafo import Graph, Vertex

class Point(Vertex):
    '''A vertex which can have a poison trap
    '''
    def __init__(self, *args):
        Vertex.__init__(self, *args)
        self.poisoned = False

    def __str__(self):
        tmp = '*' if self.poisoned else ''
        return '<' + tmp + str(self.i) + '>'

 
class Cube(Graph):
    ''' A Graph derived class in which each vertex (Point)
    may contain a poison trap or not
    '''
    def add(self, node, *nodelist):
        vertex = Point(node, *nodelist)
        self.vList[node] = vertex

    def run(self, N):
        ''' Puts an ant on vertex #1 and let it run for N
        random steps. Stops when the ant enters a poisoned
        vertex or it has run N steps. Returns ant's last position.
        '''
        i = 0
        pos = 1 # Initial ant position
        while i < N:
            i += 1
            pos = choice(self.vList[pos].nodeList)
            if self.vList[pos].venenoso:
                break

        return pos

 
if __name__ == '__main__':
    G = Cube()
    G.add(1, 2, 4, 5)
    G.add(2, 1, 3, 6)
    G.add(3, 2, 4, 7)
    G.add(4, 1, 3, 8)
    G.add(5, 1, 6, 8)
    G.add(6, 2, 5, 7)
    G.add(7, 3, 6, 8)
    G.add(8, 4, 5, 7)

    G.vList[7].poisoned = True
    G.vList[8].poisoned = True

    # Carry out simple statistics
    stats = [0, 0, 0] # Counters

    for i in xrange(1000000): # Total number of experiments (runs)
        pos = G.run(100) # make the ant to run 100 steps
        if pos > 6: # Map 0..6 => 0, 7 => 1, 8 => 2
            pos -= 6 # 7 = 1, 8 = 2
        else:
            pos = 0

        stats[pos] += 1 # Increase corresponding counter

    tot = sum(stats) # Total #number of experiments (must be the same number as above)
    print stats # Absolute Frequencies
    print [100 * float(x) / tot for x in stats] # Relative frequencies (percentage)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vim:ts=4:et:sw=4

class Vertex(object):
    def __init__(self, node, *nodeList):
        self.i = node
        self.nodeList = list(nodeList)

    def __hash__(self):
        return self.i

    def reaches(self, vertex):
        ''' Can receive an integer or a Vertex
        '''
        if isinstance(vertex, int):
            return vertex in self.nodeList

        return self.reaches(vertex.i)

    def __str__(self):
        return '< ' + str(self.i) + '>'

    def __repr__(self):
        return self.__str__()

 
class Graph(object):
    def __init__(self):
        self.vList = {}

    def add(self, node, *nodeList):
        vertex = Vertex(node, *nodeList)
        self.vList[node] = vertex

    def hamiltonian(self, current = None, pending = None, destiny = None):
        ''' Returns a list of nodes which represent
        a hamiltonian path, or None if not found
        '''
        if pending is None:
            pending = self.vList.values()

        result = None

        if current is None:
            for current in pending:
                result = self.hamiltonian(current, [x for x in pending if x is not current], current)
                if result is not None:
                    break
        else:
            if pending == []:
                if current.reaches(destiny):
                    return [current]
                else:
                    return None

            for x in [self.vList[v] for v in current.nodeList]:
                if x in pending:
                    result = self.hamiltonian(x, [y for y in pending if y is not x], destiny)
                    if result is not None:
                        result = [current] + result
                        break    

        return result

if __name__ == 'main':
    G = Graph()
    G.add(1, 2, 8, 11)
    G.add(2, 1, 6, 9)
    G.add(3, 6, 7, 9, 10)
    G.add(4, 5, 7, 10)
    G.add(5, 4, 8, 11)
    G.add(6, 2, 3, 8)
    G.add(7, 3, 4, 8)
    G.add(8, 1, 6, 7, 5)
    G.add(9, 2, 3, 11)
    G.add(10, 3, 4, 11)
    G.add(11, 1, 9, 10, 5)
    print G.hamiltonian()

Sometimes I want to make a class attribute private, so in order to access it one has to implement a read method and (if needed) a write one. They’re called getter and setter respectively (I’m not very fond of private attributes, by the way). This usually happens when the external representation of the attribute value differs with the internal one.

Both Microsoft Visual C++ and Borland Builder C++ implement getters and setters in their own way, but I prefer a standard method which can be used across every C++ standard compiler (including Intel C++ and G++, the GNU C++ compiler). Finally I worked out a solution and implemented this template, and it seems to work. Basically, it implements properties as classes:

template <typename T, class F> class Property
{
private:
	T data;
	F *_instance;
	T (F::*_getter)(void);
	T (F::*_setter)(const T &);

public:
	Property(F *instance,
                T (F::*getter)(void),
                T (F::*setter)(const T &) = NULL)
	{
		_instance = instance;
		_getter = getter;
		_setter = setter;
	}

	Property(F *instance,
                    T initialValue,
                    T (F::*getter)(void),
                    T (F::*setter)(const T &) = NULL)
	{
		_instance = instance;
		_getter = getter;
		_setter = setter;
		data = initialValue;
	}

	Property()
	{
	}

	inline operator T()
                { return (_instance->*_getter)(); }

	inline T operator =(const T &value)
                { return (_instance->*_setter)(value); }

	friend F;
};

You will usually put this template into an include file.

Now an example. It creates an <int> container (stored in an STL <vector>), with a length property. Reading this property returns vector.size() value, whilst setting a value to length will effectively resize the vector:

class IntVector {

private:
        int __setSize(const int &newValue) {
            vectorData.resize(newValue);
            return vectorData.size();
        }

        int __getSize(void) {
            return vectorData.size();
        }

public:
        std::vector<int> vectorData;

        Property<int, IntVector> length;

        IntVector():
            length(this, &IntVector::__getSize, &IntVector::__setSize)
		{
		}
};

int main(int argc, char *argv[])
{
        IntVector myVector;

        myVector.length = 32; // Sets the vector size to 32 elements
        cout << "Vector size: " << myVector.length; 

        return EXIT_SUCCESS;
}

Remember:

        myVector.length = 32; // Sets the vector size to 32 elements

effectively sets the vector length and

        variable = myVector.length; // Reads the vector size

read such length.

Note: This code is released with a CC0 (Public Domain) license, so you can use it for whatever you want.

Read more:

• Implementing Properties in C++
• Pointers to C++ Member Functions

Sometimes, when we’re working on a problem, we need to denote a variable with an uknown value. C and SQL uses NULL for this purpose, while Lisp uses nil and Python have None. Let’s look python closer: sometimes, None really means none. But there are some cases we need another semantic interpretation. For example, I like to work with the unknown value, which means something different to none (None) which I use for different a purpose. We can do this:

class Unknown(object):
    pass
[...]
if b is Unknown:
   print "Var b is unknown"

This works because in python, Classes are also objects. The is operator only returns True if two objects are the same instance. Even better, the is operator allows an interesting syntax when used with not:

if b is not Unknown:
    [...]

This not only enhances (IMHO) code legibility, it also make comments useless: the code is the comment itself.

Finally, this idea can be also used to define your own Infinitum value:

class Inf(object):
    pass

try:
   b = 1 / 0
except ZeroDivideError:
   b = Inf

if b is Inf:
   print "b is Inf"

More precisely stated, the problem is to write a source program that, when compiled and executed, will produce as output an exact copy of its source. If you have never done this, I urge you to try it on your own. The discovery of how to do it is a revelation that far surpasses any benefit obtained by being told how to do it.

I’ve never tried to code such a thing, so I put my shoulder to the wheel and try this exercise in python. After a few minutes, I got this solution. It’s not the shortest (especially considering it reproduces the shebang and the coding lines), but it works. As Mr. Thomson says, it’s a very interesting exercise. Here’s the code:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
data = ['#!/usr/bin/env python', '# -*- coding: utf-8 -*-',
        "for x in data[:2]:", "    print x",
        "print 'data = ', data", "for x in data[2:]:", "    print x"]
for x in data[:2]:
    print x
print 'data = ', data
for x in data[2:]:
    print x

Save it as prog1.py, and then execute python prog1.py.
Even better, try python prog1.py > prog2.py and then python prog2.py > prog3.py and so on.

The problem with the default reCaptcha output is that it does not validates XHTML 1.0 Strict because the use of iframes. But you can change the code at the recaptchalib.php file (available here). This problem persist at the current version (1.10 at this moment).

Replacing the code at lines #122 – #128 with:

<?php
    return '<script type="text/javascript" src="'. $server . '/challenge?k=' . $pubkey . $errorpart . '"></script>
        <noscript>
            <div id="no_js_recaptcha">
                <object type="text/html" data="http://api.recaptcha.net/noscript?k=' . $pubkey . '" width="500" height="300">
                <!--[if IE]>
                <iframe width="500" height="300" frameborder="0" src="http://api.recaptcha.net/noscript?k=' . $pubkey . '"></iframe>
                < ![endif]-->
                </object>
            </div>
        </noscript>';
?>

will do the trick

There were many other speeches both from my colleagues and from people of other universities.

The conferences were hosted at Universidat Jaume I located at Castellón de la Plana, Spain. There also is an official photo gallery. Besides that, I also took tome photos.

It was a nice experience and I met very friendly people. More photos here.

I’ve put it in my wiki, just in case anybody want to give it a glance.

My tool is better than the LEX & YACC couple in the sense it can parse LR(n) grammars whilst LEX/Yacc only parses LALR ones. It uses a Lookahead and mangle-likes estructures to take some decisions when choosing which grammar rule to use for reduction.

If it eventually cannot decide which rule should be used, it will start to backtrack to find out the rule to apply.

This tool allows ambiguos grammars, so it is very similar to a GLR parser. BISON (GNU’s YACC) can also use the GLR algorithm, but it is less efficient and can take exponential space/time to parse some entries depending on the given grammar.

The calculator example

The calculator example is the “Hello World” of parsers generators. Below there is an calculator definition for mathematical expresions. Simply run the program and enter a mathematic expression like 1+3.2*5^2 and the program will output the result to the screen (with some explanation about rules used). The program will finish when you enter an empty input.

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys

from bparser import Token
from bparser import Symbol
from bparser import Bparser

class Calc(Bparser):
	def minus_factor(self, symbol, l):
		symbol.value = -l[1].value
		return symbol
	
	def term_mul_term(self, symbol, l):
		symbol.value = l[0].value * l[2].value
		return symbol
	
	def term_div_term(self, symbol, l):
		symbol.value = l[0].value / l[2].value
		return symbol
	
	def term_plus_term(self, symbol, l):
		symbol.value = l[0].value + l[2].value
		return symbol
	
	def term_minus_term(self, symbol, l):
		symbol.value = l[0].value - l[2].value	
		return symbol
	
	def term_pow_term(self, symbol, l):
		symbol.value = l[0].value ** l[2].value
		return symbol
	
	def print_result(self, symbol, l):
		print 'Result is', l[0].value
		return symbol
	
	def lprp_action(self, symbol, l):
		symbol.value = l[1].value
		return symbol

	def default_hook(self, symbol, l):
		symbol.value = l[0].value
	
		print symbol.name, '-->', [x.name for x in l]
		print 'ValueOf(%s) = ' % symbol.name, symbol.value 
	
		return symbol

calc = Calc()

calc.add_token(r'[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?', 'NUMBER')
calc.add_tokens({r'\+': 'PLUS', r'\-': 'MINUS', r'\*': 'MUL', '/': 'DIV', '%': 'MOD', r'\^':'POW'})
calc.add_tokens({r'\(': 'LP', r'\)': 'RP'}) # Escape PARENTHESIS in Regular Expressions
calc.add_token('[ \t\n]+', ('SEPARATOR', Token.skip))

calc.parse_rule('%LEFT (PLUS, MINUS)')
calc.parse_rule('%LEFT (MUL, DIV)')
calc.parse_rule('%RIGHT (POW)')
calc.parse_rule('Program --> expr .print_result')

calc.parse_rule('expr --> term')

calc.parse_rule('term --> term PLUS term .term_plus_term')
calc.parse_rule('term --> term MINUS term .term_minus_term')
calc.parse_rule('term --> term MUL term .term_mul_term')
calc.parse_rule('term --> term DIV term .term_minus_term')
calc.parse_rule('term --> term POW term .term_pow_term')

calc.parse_rule('term --> value')
calc.parse_rule('value --> LP expr RP .lprp_action')
calc.parse_rule('value --> NUMBER')
calc.parse_rule('value --> MINUS NUMBER .minus_factor')


if __name__ == '__main__':
	while True:
		input = sys.stdin.readline().strip()
		if input == '': break
	
		calc.set_buffer(input)
		calc.verbose = False
		calc.start()
		calc.storage.pow_level = []
	
		if calc.parse():
			calc.verbose = True
			calc.mimic()
		else:
			print "Syntax Error."

I’m using this tool in the ZX Spectrum BASIC Compiler, that will serve as a test-language for this tool.

I’m using it and find it very useful. However, within my organization, I must connect to the internet via an HTTP/HTTPS proxy firewall. Direct internet connections are filtered, so I developed a hack to make it to work via an HTTP(S) proxied connection.

Basically I ripped the code from this ASPN snippet, and derived the urllib proxied transport to create a new one.

To use it behind a proxy, you can copy the libgmail example, and define the proxy this way:

import libgmail

libgmail.PROXY_URL = 'www.myproxy.org:3128'  # Define the proxy.

ga = libgmail.GmailAccount("google@gmail.com", "mymailismypass")
ga.login()
folder = ga.getMessagesByFolder('inbox')

for thread in folder:
    print thread.id, len(thread), thread.subject
    for msg in thread:
        print "  ", msg.id, msg.number, msg.subject
    print msg.source

I patched the libgmail.py file and write the proxied transport in another one: gmail_transport.py. You will need to copy both the file gmail_transport.py and the modified version of libgmail.py (overwrite it) into the same directory libgmail.py is installed.

There is also a diff file available, for libgmail-0.6.1.2.

Update (2007-10-06): It’s now possible to use proxy authentication. To do it so, you must use the proxy host address on the previous example this way: user:password@myproxy.org:3128 where user and password are your proxy user and password respectively. You’ll have to download again the file gmail_transport.py.

Now, the example to use it behind a proxy requiring with user/passwd authentication is like this:

import libgmail

# Connect from behind a proxy www.myproxy.org:3128 using
# proxy authentication user = 'john', password = 'proxy4321'
libgmail.PROXY_URL = 'john:proxy4321@www.myproxy.org:3128'  # Define the proxy 

ga = libgmail.GmailAccount("google@gmail.com", "mymailismypass")
ga.login()
folder = ga.getMessagesByFolder('inbox')

for thread in folder:
    print thread.id, len(thread), thread.subject
    for msg in thread:
        print "  ", msg.id, msg.number, msg.subject
    print msg.source