Yue Zhang - Techlog

SRILM note: the use of MACHINE_TYPE for customized compilation

2011-07-16T04:36:00.000-07:00

SRILM supports compilation for different architectures by the MACHINE_TYPE variable. By default, MACHINE_TYPE is defined automatically. However, for special purposes, such as 64 bit support, MACHINE_TYPE can be manually specified. For a particular machine type x (i.e. i686, i686-m64, i686-gcc4), the corresponding compiler options are defined in common/Makefile.machine.x. When running 'make MACHINE_TYPE=x', a separate folder x will be created under bin, lib, lm/obj, dstruct/obj and other folders. The fact can be taken advantage of when making a specific compilation of the code. For example, suppose that we want to compile a position independent version of srilm for sharing. We can do this by copying one machine specific makefile, such as Makefile.machine.i686, to Makefile.machine.foo. Then we can modify the compiler flag of foo, adding what we need. For this particular case, it is -fPIC. Then we compile srilm by 'make MACHINE_TYPE=foo'. The resulting objects, such as liboolm.a, will be placed at lib/foo. This is handy since it does not clash with existing libraries and binaries.

OpenOffice Note: selecting all footnotes

2011-07-08T06:48:00.000-07:00

The current version of OpenOffice writer does not directly support the extracting of all footnotes, but there are ways to get around this. First, footnotes can be selected by Edit | Find & Replace ..., and then choosing More Options, and ticking Search for Styles below. Choose Footnote as the style in the drop down list above, then press the button Find All. All foot notes will be highlighted, and then can be copied into clipboard. Second, when trying to paste the selected footnotes into a target file, it turns out that all new lines after footnotes are gone. This can be solved by the following trick.

(1) In the original document from which footnotes are extracted, select all footnotes in the aforementioned way.

(2) (Assuming that each footnote ends with a period) remove trailing space characters (if any) by using Find and Replace, ticking Current Selection Only and Regular Expression in More Options. Find all patterns: [ ]+$ (note the space between [ and ]) and replacing them with an empty string (by emptying textbox).

(3) Again select all footnotes in that document, and then use the same method is the previous step to replace pattern \.$ with .ENDOFPARAGRAPH. The special word ENDOFPARAGRAPH is used as a placeholder for newline.

(4) Use the method mentioned before to select all footnotes again now, and copy them and paste them into a new document.

(5) from the new document, use Find and Replace to replace all ENDOFPARAGRAH with \n, ticking Find Regular Expression under MoreOptions.

That will do the extraction. Use an Undo step to undo the insertion of placeholder words in the original document. Or simply replace them again with ''.

C++ note: commas and brackets in a macro

2011-06-18T04:05:00.000-07:00

Sometimes it's handy to use a macro to avoid repeated writing of similar code, especially when there is no direct way to modularize some apparently similar but essentially very different functions. In such uses of macros it often occurs that commas and brackets need to be included in the macro. Direct inclusion of commas and brackets may confuse the compiler.


#define example_macros(left_code, right_code)\
left_code a right_code\
left_code b right_code\
left_code c right_code\
...
left_code z right_code

void func_1() {
   example_macros( my_module1.call( , ); );
}

void func_2() {
   example_macros( cout<< , <<(endl); );
}

When the usage become more complex, particularly when there are more arguments to macro, commas and brackets may confuse the macro. The bets solution I have found is using extra macros.


#define id_comma ,
#define id_left_bracket (
#define id_right_bracket )

and then replace the usage of commas and brackets in macros


void func_1() {
   example_macros( my_module1.call id_left_bracket , id_right_brackt ; );
}

This will avoid any confusion.

Bash note: get the path for the running script

2011-03-02T07:45:00.001-08:00

The following expression returns the path the currently running script is from (note that the script might not be from pwd):

$(cd `dirname $0` && pwd)

Python note: breaking a long statement to add end of line comments

2011-01-20T06:12:00.000-08:00

There is a very simple tip for breaking a long line in order to add end comments. Python doesn't recognize arbitrary broken lines, but it allows lines to be broken if the line is inside a bracket so it is unambiguous. The following code


if condition1 and # comment1
   condition2: # comment2

would not work because a line is broken in the if statement, however,


if (condition1 and #comment1
    condition2): # comment2

would fix the problem and maintain neat code.

Python note: set equality test

2011-01-20T04:33:00.001-08:00

Given a class with an __eq__ function, would a python set contain only members that are equal? The answer is not necessarily.

Consider the following class:


class C(object):
   def __init__(self, x):
      self.a = x
   def __eq__(self, o):
      return self.a == o.a
   def __str__(self):
      return str(self.a)

It defines a member which controls its equality. However, the following code will add four members to the set


s = set()
a = C(1)
b = C(2)
c = C(3)
s.add(a)
s.add(b)
s.add(c)
s.add(C(1))

The main reason is that set is implemented as a hash map, and without a hash function defined in the class C, python will use the object identity itself for hashing, and members of the class will be hashed into different places. The following code will fix the problem.


class C(object):
   def __init__(self, x):
      self.a = x
   def __eq__(self, o):
      return self.a == o.a
   def __str__(self):
      return str(self.a)
   def __hash__(self):
      return self.a

grep note: find all words that contains a particular substring

2011-01-18T08:08:00.000-08:00

I used:
grep -h substring path/*.txt | tr ' ' '\n' | grep substring

grep substring path/*.txt will list the files plus the matching lines.

grep -h substring path/*.txt will remove the names of the matching files, leaving only lines.

grep -h substring path/*.txt | tr ' ' '\n' will translate the matching lines into a word-per-line form.

grep -h substring path/*.txt | tr ' ' '\n' | grep substring will then filter the words that do not contain the pattern from the lines.

I also wanted a list of unique words that contained the substring, and therefore piped the previous command into sort and uniq.

C++ note: pure virtual method called

2010-11-09T09:41:00.001-08:00

The first thing to check is whether virtual functions are called from constructor.
http://www.artima.com/cppsource/pure_virtual.html

C++ note: static variable from inline member function

2010-10-30T08:57:00.000-07:00

I was thinking about Meyers singleton, and wonder how compilers will handle the same static variable defined in difference modules due to inline function expansion. Here are some relevant discussions (it occurs safe not to use the kind of singleton(?)).

http://objectmix.com/c/250462-static-local-variable-inline-static-member-function.html

Sh note: adding a line at the front of files

2010-10-13T06:42:00.000-07:00

The example script adds a new line to the beginning of each file in the directory, recursively, except those files that contain svn.

for file in `find . -type f | grep -v 'svn'`;
do
sed '1i\New line' -i $file
done

Sh note: reversing a file or a line

2010-10-12T07:49:00.000-07:00

rev can be used to reverse a line character by character
tac can be used to reverse a file line by line
these two commands are sometimes handy

sh$ rev
abc
cba

sh$ tac
a
b
c^D
c
b
a

echo abcde | rev

a particular context I used tac
ls /corpora/extra/nivre/corpus/conll-x/data/turkish/metu_sabanci/*/*.conll | cut -d '/' -f8-11 | tac

C++ note: enabling and disabling assert

2010-03-17T08:43:00.000-07:00

In C++, assert is by default compiled. To exclude it, the macro NDEBUG must be defined when assert.h is included. This can be done by using -DNDEBUG compiler option or #define NDEBUG in code.

gcc -DNDEBUG -c test.cpp -o test.o

LaTeX note: two columns

2009-11-09T08:13:00.000-08:00

To make a new page with two columns:

\begin{twocolumns}
...
\end{twocolumns}

Two columnns at the same page

\begin{multicols}{2}
...
\end{multicols}

Linux note: recursive replacement

2009-08-24T14:37:00.000-07:00

This is a script to recursively do pattern replacing with dir

-----------------------------------
if [ $# -ne 3 ]
then
echo 'Usage: replace.sh dir pattern1 pattern2'
exit 85
fi

for f in `grep -rl $2 $1`;
do
sed "s/$2/$3/g" -i $f
done
--------------------------------------

$1 is the directory, $2 is the pattern to be replaced and $3 is the new pattern. This script iterates through all files in directory. Filtering can be done by changing the for loop into a detailed list of files.

C++ note: using a functor to help organise a vector of pointers

2009-04-21T07:46:00.000-07:00

Suppose that some large structures need to be managed by using a heap. There is no limitation to the number of items, and therefore a vector is used to maintain the memory. Because they are organised in a heap, direct heap operation on the memory vector is slow. Therefore, another vector is used to store the indice.

template<cnode> myClass{
vector<cnode> memory;
vector<unsigned> indice;
}

Now the indice vector must store indice (unsigned) rather than pointers (CNode*). This is because when the memory vector is reallocated, the original pointers to the memory are invalid. Using pointer vectors will lead to segmentation-fault.

Pushing and popping heap operations can now be carried out on the indice. They should rely on node comparison. The standard node comparison function should read like:

// in myClass
bool less(const unsigned x, const unsigned y) { return memory[x] < memory[y]; }

The above code does not compile, because push_back and pop_back in std require a function with the signature less(x, y). A member function doesn't work. A solution is the functor.

struct CNodeLess {
const vector<CNode> *memory;
CNodeLess(const vector<CNode> &bm): memory(&bm) {}
bool operator()(const unsigned &x, const unsigned &y) { return (memory[x] < memory[y]); }

Now the class can have a member in CNodeLess that caches the memory, and provide the less(x,y) signature.

Linux note: grep command

2008-12-11T08:33:00.000-08:00

To grep multiple patterns from a file

grep -E "patternone|patterntwo" file

The option -E is to enable extended posix regular-expression (|). The quotation marks are to prevent the shell from taking | for pipe.

Java note: toarray

2008-09-26T12:56:00.000-07:00

Because of the implementation of containers, the contained type cannot be instantiated within them. An inconvenient consequence is toArray. There are two ways to call it

1.
Object arr[] = list.toArray();

But it's not easy to change Object[] to Type[].

2.
Type arr[] = new Type[m];
list.toArray(arr);

But it would be much better not to have to allocate arr separately.

The next version of Java should really reconsider the implementation of templates.

Java note: generics

2008-09-17T07:58:00.001-07:00

In Java 1.5 (and 1.6), generics is used by containers to avoid runtime type cast. Generics are not implemented in the same way as C++ templates, and are much less flexible. A generic class is compiled into only one class file, instead of one for each template instance. A big disadvantage is that a generic container cannot make new instances of its elements.

Java note: assertion

2008-09-17T07:58:00.000-07:00

The assert statement in Java are ignored from compile by default. To enable assert, add -ea when compiling.

javac -ea example.java

Python note: swapping objects

2008-07-10T14:07:00.000-07:00

The best way to swap two objects is:

a, b = b, a

It swaps the names of two object by the use of a tuple, without altering the objects.

The way to swap objects in many languages involves copying. However, this method can be tricky with Python. This is particularly because object assignment in Python does not copy objects. It simply links a variable name to the existing object. Suppose

class X(object):
__init__(self, x)
self.x = x

a = X([1, 2, 3])
b = X([])

Then we want this:

b = a
a.x = []

The above will not work, because b.x will become [] too. To avoid copying, use

a, b = b, a
a.x = []

In another occasion, if a will be kept while b becomes a copy of a's value, define a copying function or use the copy module.

With the new-style class, everything is an object. So the rule for object assignment applies to lists, dicts etc. To make a copy of the original list, use l2 = l1[:].

Python note: functional programming saves code when dealing with lists

2008-07-07T03:20:00.000-07:00

Another note on using functional programming. It makes code with lists shorter and clearer sometimes.

For example, there is a list l. We want to add one to each element:

l = map(lambda x: x+1, l)

LIBSVM note: problems

2008-07-07T03:10:00.000-07:00

1. Why does svm-scale run forever, while keeping writing the output file (.scale)?

It might be because the original training file contains [0, 1] range features, but the scale output requires [-1, 1] range. This is the default option. Add the option -l 0.

2. Why does svm-train run forever?

It might be because of the epsilon value. The default parameter (-e 0.001) sets this value. The smaller the value is, the more accurate will the trained model be, but the more iterations will be taken. Consider setting epsilon to 1 and try.

If there are a lot of features, consider trying LIBLINEAR instead. It does not use a kernel, but runs faster than LIBSVM for a linear model.

Another param, -m, sets the memory cache. Make it as large as possible within RAM.

Python tool: Chinese Treebank

2008-05-20T09:02:00.000-07:00

I have put some scripts to process the Penn Chinese Treebank to
Google code. These files include a parser to turn bracketed annotations into Python objects, a converter to translate POS tags into the Stanford tagger format, and a set of head finding rules to translate CTB into dependency trees.

I haven't made any releases for download, but have been updating the source code. The files are available by browsing the trunk from the SVN repository.

Python note: reversing lists

2008-04-01T09:04:00.000-07:00

There are two ways to reverse a list. One way is to modify the original list:

l = [1,2,3]
l.reverse() # l becomes [3,2,1]

The other way is not to modify the original list, but make a copy:

l = [1,2,3]
l[::-1] # l remains

Notes: l[start:end:step] makes a new sequence from l by slicing. For example, l[1:2] makes a new list [2] and l[0:3] makes [1,2,3]. l[:] is often used to make a copy of the whole list l. This is useful when we want to pass the value (not rerence) of l to a new list.

Python note: the difference between getattr and getattribute

2008-03-30T04:54:00.000-07:00

I tried to overload __setattr__ today, so that when a value is assigned to item.type, I can check whether it is in the set of possible choices. However, I made a mistake by defining a __setattribute__ function instead of __setattr__.

There is no special function named __setattribute__. The only functions that intercepts attribute accesses in Python are __getattr__, __getattribute__ and __setattr__. The difference between __getattr__ and __getattribute is that, __getattr__ is called when the attribute is not in the object's dictionary, while __getatttribute__ is called whenever the attribute is accessed. Therefore, __getattribute__ will make the speed slower. __setattr__ is the same as __getattribute__ in the triggering mechanism -- it intercepts the assignment operation no matter the attribute to modify already exists or not.

Another note about __getattr__ is that the overloaded method must raise attribute error itself or the program may run into unexpected output. For example, there is an overloaded __getattr__ method:

class Foo(object):
   def __getattr__(self, attr):
       if attr == "bar":
          return "bar"

foo = Foo()

Now when we try to see foo.barrrr which doesn't exist, we get None value instead of a thrown attribute error. The code should be corrected into:

class Foo(object):
    def __getattr__(self, attr):
       if attr == "bar":
          return "bar"
       else:
          raise AttributeError, attr

Python tool: traditional to simplified Chinese converter

2008-03-20T04:29:00.000-07:00

I just wrote this script to convert traditional Chinese text to simplified Chinese. Since the relationship between traditional and simplified characters is many to one, I haven't decided to write the revert convertion script.

It has been tested with my files and can be downloaded here, and please report bugs and suggestions if you found any.

The package contains two files, simplify.py and utftable.txt. The python script is the converter and utftable.txt is the character table. The two files must be put into the same directory.

Usage:
python simplify.py input.txt >output.txt

Both the input and the output text files must be in UTF8.

Note that you can replace the character relationship table file with your own file (the new file must be in the same format as the original file), just in case there are more comprehensive tables than this one.

sqlite note: using the command line tool

2008-03-18T14:07:00.000-07:00

The command line tool sqlite3 can be used to view the content of a database. One way of using it is typing in "sqlite3 FILE" and the database contained in FILE is opened for query commands.

The command line tool sqlite3 can also be used to perform a query directly. For example, typing "sqlite3 FILE 'select * from Table1'" will print out all contents in table Table1. This is handy for showing large tables, because we can pipe the output into a reader tool. "sqlite3 FILE 'select * from Table1' | more".

C++ note: static_cast from a reference to a value

2008-03-10T11:17:00.001-07:00

By default, the result of a static_cast is a r-value. It can't be used as a l-value, and thus can't be given a new value.

Such misuse will lead to compile errors. But the report from the compiler can be misleading or quite hard to understand. For example, suppose we have a base class Base and a derived class Derived from Base. We want to overload the istream >> operator for Derived. The following way to overloading the operator does not work:

istream & operator >> (istream &is, Derived &derived) {
// special processing
is >> static_cast<Base>(derived);
}

This is because the result for casting will be passed as a reference function parameter. The reported error from the compiler has nothing to do with cast, however, and it simply sais that there is no match for operator >> from ...

It should be noticed that even if the cast is done for pointers, the results are still r-values.

To avoid the above problem, use static_cast<Base&>.

Python note: the main entry of a python file

2008-01-28T02:52:00.000-08:00

In a python module we could write

if __name__ == "__main__":
# the main program entry
...

and this is often taken as the main entry of the module. The fact may be misleading for C++ programmers, because python doesn't actually need a main entry when running a module.

Unlike C++, each python module is treated as a sequence of executable commands. No matter when it is imported or run as a program, python always executes the python file from the first line to the end. This is also the reason why python is called a script language. Generally, there are three types of commands in python

1. import commands: when python meets these commands, it checks sys.modules to see if the imported module is already in the list. If it is, python bypasses this command. Otherwise, python goes into the imported module and runs every command in it.

2. definition commands: these commands include "class" and "def"; when python meets them it doesn not do anything, but remembers the definitions in the corresponding place (normally in the __dir__ of the current module).

3. execution commands: all the other commands, including assignments, conditions and branching statements, function calls etc; python runs them according to their semantics.

When a module is loaded into python as the main program, python gives the module name __name__ the special value "__main__". The condition check for __name__ == "__main__" is used to make sure that the commands below are executed only when the module is run as the main program, but not as an inmported module. There can be as many such conditions as possible, and they can occur anywhere in a python module. There is not a particular function or statement that python takes as the main entry of modules.

C++ Makefile case study: incorrect dependencies cause unexpected errors

2008-01-25T07:53:00.000-08:00

Incorrect dependencies in Makefiles can cause not only timestamp confusion, but also unexpected errors and segmentation faults after compiling.

Suppose that there are three files: header.h, module1.cpp and module2.cpp. Both cpp files include the h file for the definition of common structures. module1 generates module1.o and module2 generates module2.o, which will be linked together.

Now in the make file, suppose header.h was missing from the dependencies of module1.o and module2.o. An immediate problem that arises is that a "make" command won't compile the program if only header.h is modified after the last build. But this is not the worst problem. Suppose both header.h and module1.cpp are modified, and the common structure is touched. Now when "make" is executed, it's possible that nothing happens at compile time, but various strange bugs or unexpected results come out later at runtime. The reason is that module2 is still using the out dated version of data structure. Such a case can be confirmed by running "make clean" and then compile again to see if the unexpected errors go away.

C++ question - linker failed

2008-01-14T03:00:00.000-08:00

I defined a constant boolean in an external header file:
const bool CONDITION = false ;

Then I wrote in a function the following line:
void func(...) {
...
if (cond) {
   if (CONDITION) {
      ...
   }
   else
      ...
...
}

Then g++ couldn't compile the code, reporting that the linker couldn't find the function.

I haven't figured out why it happended, but a solution is changing the if statement and constant bool value into a #ifdef directive and a macro.

latex note: minipage with borders

2007-11-22T10:38:00.000-08:00

One way to add borders to a minipage is embedding it into an fbox. For example:

\fbox{
\begin{minipage}[t]{0.5\textwidth}
...
\end{minipage}
}

C++ note: initializers in multiple inheritance

2007-11-09T04:26:00.000-08:00

Here is a tutorial on C++ multiple inheritance.

A C++ class can inherit multiple base classes. If these base class still have base classes, they will be initialized separately by default. (For each parent class, the subclass will contain the inherited structures) For example, suppose B and C derive from A, and D derive from B and C, D will have two copies of A. One inherited from B, and the other from C.

In some occasions only one copy of A is needed in D. This type of inheritance is enabled by letting B and C virtually derive from A. By virtual inheritance, B and C no longer encompass the structure of A into their structure, but include a pointer to the A structure in their vtables. When D derive from B and C, the compiler generates only one A structure that is shared by B and C.

Here comes a question: in the constructor of D, what structures do we need to initialize?

class A {
public:
   int a;
  A ( int i ) : a (i) {}
}

class B : virtual public A {
public:
   B ( int i ) : A(i) {}
}

class C : virtual public A {
public:
   C ( int i ) : A(i) {}
}

class D : public B, public C {
   D ( int i ) : A(i), B(i), C(i) {} // <-------------
}

In the above example, D has to initilize A, B and C in its constructor. The initialization of A is mandatory even though both B and C do have the initializers in their constructor. When D is constructed, the initializers of B and C will not assign any value to A by default. This fact can be observed by removing the initialization of A in D, and printing the a field from D-object.

C++ note: avoid allocating large structures in the stack

2007-11-08T05:38:00.000-08:00

Unexpected segmentation fault when calling a function can be caused by big memory allocation in the stack. The following piece of code will fail.

class Big {
   int data[10000000000];
};

void test() {
   cout << "entering test";
   Big big;
}

void main(int argc, char** argv) {
   test();
}

The reason is this: when test() is called, the variables declared in this function are put to the stack ( which is a special area of memory for function calls, commonly supported by a stack pointer in the CPU architecture ). The size of the stack is limited, and putting too much data in it can cause unexpected errors without warning. ( Note that compilers may choose to push stack before any executions, and therefore the "entering test" hint might not be printed. ) This kind of error is hard to trace during debugging. With new CPU architectures, the stack size may be improved, but this trap is still commonly seen nowadays.

To void such segmentation faults, we need to put the big structures into the heap. Two methods can be used. One is allocating memory inside the class:

class Big {
   int *data;
   Big() { data = new int[10000000000]; }
   virtual ~Big() { delete data; }
};

The other is allocating memory inside the function instead:

void test() {
   cout << "entering test";
   Big *big = new Big;
   delete big;
}

C++ note: pointer and reference

2007-11-07T08:21:00.000-08:00

The semantics of the * operator is to get the value from a pointer. When it is used as a reference, *p converts the pointer to the reference of the object it points to. This is illustrated with the following example.

void reference( int &i ) { i = 4; }

void testReference() {
   int i=5;
   int *p = &i;
   reference( *p );
   cout < < i << endl;
}

As can be seen from the output (4), the i in the testReference method is actually modified. This shows the semantics of the * operator, when used as a reference.

C++ note: predefined macros

2007-11-02T08:26:00.000-07:00

The standard C++ compilers all support the following macros:

__DATE__ - a string literal containing the date when the source file was compiled, in the form of "Mmm dd yyyy".

__FILE__ - a string literal containing the name of the source file.

__LINE__ - an integer representing the current source line number.

__STDC__ - defined if the C compiler conforms to the ANSI standard. This macro is undefined if the language level is set to anything other than ANSI.

__TIME__ - a string literal containing the time when the source file was compiled, in the form of "hh:mm:ss".

__cplusplus - defined when the compiler supports c plus plus.

These macros can be used anywhere in the source code, just as if they were defined by the #define directive. Their value changes according the the specific file and line in the source code. Therefore, we can use them to implement error reporting that includes file and line numbers in C++ source code.

#define REPORT(x) cerr << endl << "In " << __FILE__ << ", line " << __LINE__ << ": " << endl << x << endl; cerr.flush();

C++ note: operator precedence

2007-10-29T05:05:00.000-07:00

Another common trap is the precedence between == and & | ^

The expression a & b == 0 is interpreted as a & (b==0) instead of (a & b) == 0, quite different from a + b == 0.

Conclusion: always add brackets when evaluating the bitwise operators & | ^

Compile log: SRILM

2007-10-01T09:17:00.000-07:00

SRILM is a language modelling package, used by the moses translation system. The compilation is quite straightforward, except two things:

1. The current path in the Makefile needs to be changed
2. In common/Makefile.machine.xxx, there are paths to gcc and g++.
In the first line, GCC_FLAGS might need editing as well. For example, -mtune=pentium3.

vim note: grep

2007-09-16T07:18:00.000-07:00

The handy tool grep from Linux can also be used in VIM, by just typing ":grep PATTERN FILES" in the command mode. It finds the string according to the input pattern from all designated files. Note that FILES needs to be in the format of absolute path. Wildcard, such as "c:\\files\\*.txt" can be used. In version 7.0, "\\" is required for the path splitter under windows. "/" does not seem to work. Regular expression could be used for PATTERN.

By default, only the first search result is shown. Use ":cn" to navigate to the next search result, and use ":cp" to navigate to the previous result. The navigation can jump from one file to another, of course. When multiple buffers (or files) are opened, use ":bn" and ":bp" to jump from one file to the other. Use ":bd" to remove a file from buffers.

mod_python note: sessions

2007-09-15T09:55:00.000-07:00

mod_python has its own modules for Session and Cookies. The mod_python documentation contains consise explanations about the usage. Cookies are used for session maintenance. An introduction can be found here.
Python supports cookies by a built in module, which is probably developed for CGI programming before adopted into Python core. mod_python can use this module as well for cookies.

Python note: using the windows clipboard

2007-09-15T09:35:00.000-07:00

The windows clipboard allows HTML content to be processed. A specification about the specific format can be found here.

A python support for the windows clipboard is found in this site package.

A recipe for using the clipboard, written by Phillip Piper, can be found from this web page. I gave a simplified version of putting something into the clipboard at here.

Apach note: mod_python global objects

2007-09-09T12:08:00.000-07:00

The term "global objects" in this article means the objects that exists from the starting of the web server until the shutdown. An example of such global objects is a database proxy, which is initialized at server start, and handles database calls during all the serving session.

At the first look, it appeared to be no place for defining global objects, for mod_python runs on the per-request basis, with each request being mapped to a call.

However, mod_python has the advantage over CGI that a python interpreter is created for one virtual server to handle all requests to server. The interpreter starts when the server starts, and last until the server is shut down. Here is a reference for the multiple interpreter mechanism for the mod_python module.

To take this advantage, global variables can be place in the global namespace for the Python interpreter. For example, it could be intitilized from a module's namespace.

Apache note: set up a mod_python server

2007-09-09T11:59:00.000-07:00

Though the building of mod_python can be a little daunting under UNIX, it's quite easy to start a mod_python server with apache under the windows platform.

Suppose that a machine has python installed.

First download the apache http server from the apache web site. (you need to find the download site by following the links from the main site) Current version is 2.2.

Second download the mod_python binaries for windows from the mod_python web site. Current version is 3.3

Third install apache following the instructions.

Fourth install mod_python following the instructions. The information in the last page is important. The LoadModule command must be added to the httpd.conf file for apache so that the http server recognizes mod_python.

The installation test can be found the documentation Note that http://127.0.0.1/test/*.py will work. This is because the request url is handed to mptest.py as parameters.

Latex note: how to shrink tables

2007-09-09T11:54:00.000-07:00

To reduce the size of a table, two general methods can be used.

1. Shrink the the font size.
For example, use \small{content} instead of content in the table cell.

2. Squeeze space between columns.
For example, a table could be written in the following way
\begin{tabular}
\setlength{\tabcolsep}{1pt}
...
\end{tabular}

C++ note: unsigned int

2007-08-25T05:50:00.000-07:00

Suppose a is an unsigned int, the expression a>-1 is always false. This is because the type of -1 is decided by the type of a, and it becomes maxint.

Hint: remember the unsigned int variables in the code and do not compare them with a minus number. The comparison itself is not necessary.

Linux note: how to disable output

2007-08-01T11:31:00.000-07:00

One way is adding a redirection to the command to execute:

command >/dev/null

In the above line, command is executed with its output redirected to /dev/null.

More notes about the above syntax. ">" is the operator to direct the output of command to a file. In this case, the file is the special device /dev/null. The standard output (using ">") and the error output ("2>") can both be redirected. To redirect the standard output and the error output at the same time, use ("&>"), and to append the redirected output to a file, use (">>").

Disabling output is necessary in many situations. For example, when using nohup, the system output is put into the file nohup.out. If the disk space is limited, we may want this file to be as small as possible. Therefore, we may put necessary information into the error output, and redirect the standard output to null.

VIM note: viewport

2007-06-16T03:27:00.000-07:00

It's sometimes necessary to split the view of a file into many windows. Below is a cheatsheet copied from here.

:sp will split the Vim window horizontally. Can be written out entirely as :split .
:vsp will split the Vim window vertically. Can be written out as :vsplit .
Ctrl-w Ctrl-w moves between Vim viewports.
Ctrl-w j moves one viewport down.
Ctrl-w k moves one viewport up.
Ctrl-w h moves one viewport to the left.
Ctrl-w l moves one viewport to the right.
Ctrl-w = tells Vim to resize viewports to be of equal size.
Ctrl-w - reduce active viewport by one line.
Ctrl-w + increase active viewport by one line.
Ctrl-w q will close the active window.
Ctrl-w r will rotate windows to the right.
Ctrl-w R will rotate windows to the left.

C++ note: mix with C code

2007-06-12T03:31:00.000-07:00

The easiest way to make use of C modules is including the header files with

extern "C"
{
#include <a_c_module.h>
}

Then the C++ compiler knows that the header defines the structures in the c way, and will compile references in the C++ module in a compatible way.

For the standard libraries name "cblabla", extern "C" is already included in the header files. This is the reason why modules etc can be included directly.

For the linker, different vendors might have different standards to mangle the refernece names. Therefore, it needs to be confirmed that the C modules are compiled in a compatible way as the C++ module.

Making use of C++ modules from C modules is harder than the other way around. For the C++ programmers, it might be possible to turn some necessary C files into the C++ format and then compile the whole project as C++. Many files can be kept as the C modules and linked explicitly.

Javascript note: about the regular expressions

2007-06-04T09:42:00.000-07:00

Javascript supports regular expressions as a built in language feature. Regular expressions are enclosed between two "/".

Here is a tutorial.

Python note: python eggs

2007-05-29T13:41:00.000-07:00

"Eggs to Python are like Jars to Java..."

More information

C++ note: static variables

2007-05-24T13:06:00.000-07:00

C++ is different from Java and csharp in the way classes are defined. The header files in C++ are not actually compiled into the object - they are only an indicator of how the data structures are organized, i.e. the reference to a member is the base address plus how much offside. All variables and functions to appear inside objects must be defined in the cpp files. The methods in header files are treated as inline methods.

Now static variables are those that occur in the heap. They exist from the beginning until the finishing of the running of program. All variables defined in a cpp file are static variables, they are by default external linked. If a variable defined in a cpp file has explicit "static" modifier, it is internal linked and can only be accessed by the module. Static variables can also be defined inside functions and methods, in which case they are still present all through the running of a program; however, they can only be accessed from the name scope in which they are defined. The accessibility is the only difference between static variables. Lastly, constants in header files are also taken as static variables. This is why values can be assigned to them in the header files.

g++ note: don't forget -c option

2007-05-22T04:12:00.000-07:00

I made a mistake when writing Makefile today, by missing to put -c for the compile-only step. It led to a lot of unresolved external references.

Latex note: generating letter size papers

2007-05-14T08:13:00.001-07:00

latex paper
dvips -t letterSize -Ppdf -G0 paper
ps2pdf -sPAPERSIZE=letter paper.ps

If the last step doesn't work, try the following command:
ps2pdf paper.ps

It should work because the ps file already contains size information.

Latex note: more on making EPS graphs from MS Office

2007-04-12T08:30:00.000-07:00

Please see my previous article about how to generate an eps chart from from MS Excel.

You can also insert Word pictures into eps. The mechanism is the same as Excel. First, make an empty word document or page to draw the vector graphs. Then print the page, using general eps printer. Lastly, modify the page bounding box of the eps file so that it fits the graph.

There is one thing to notice though: the coordinate counts from bottom left to top right! If the four numbers represent top left and bottom right, the picture will still show in latex document, but it will be sqeezed together with text because the size is below zero!

Latex note: use minipage to align a figure of text to center, while keeping text aligned to left

2007-04-12T08:27:00.000-07:00

Sometimes we need to align text with multiple lines to the center of page.

\begin{figure}[t]
\centering
this is first line \\
\hspace*{0.5cm} this is second line \\
this is third line \\
this is fourth line
\caption{caption}
\label{l}
\end{figure}

The above may not work because all lines are aligned to center, and they look messy on the left border. The solution is using a minipage to align text inside figure.

\begin{figure}[t]
\centering
\begin{minipage}[t]{0.5\textwidth}
this is first line \\
\hspace*{0.5cm} this is second line \\
this is third line \\
this is fourth line
\end{minipage}
\caption{caption}
\label{l}
\end{figure}

Latex note: protect citations in caption

2007-04-11T05:19:00.000-07:00

\caption{xxx \cite{yyy}} won't work, it won't compile with latex sometimes.

use \caption{xxx {\protect \cite{yyy}}} instead.

Python note: os.path.join unexpected result for paths beginning with "/" or "\"

2007-03-31T07:40:00.000-07:00

Need to pay attention when joining paths beginning with "/" (or "\" for windows).

os.path.join("c:\abc", "def", "ghi") -> no problem, c:\abc\def\ghi

os.path.join("c:\abc", "\def") -> outputs "\def".

C++ note: be careful with unsigned

2007-03-23T12:54:00.000-07:00

I just made a mistake with an unsigned integer. It took me nearly an hour to debug, just to find that the subtle bug is caused by this:

if (a<b-2) ...

a = 0 b = 1

b is an unsigned integer.

The reason is that b-2 is interpreted as unsigned integer, and therefore the predicate wrong. The conclusion is that we should avoid using many minuses for unsigned.

if (a+2<b) is the solution for this problem

Latex note: convert Excel charts to eps files

2007-01-12T15:13:00.000-08:00

This tip applies to any chart from MS Office.

In short, in order to insert charts from Excel to your Latex document, you need to (1) print your chart from MS Office into an eps file; (2) modify the bounding box in the output.

You need to install Generic Postscript Printer from Adobe first. Link the printer to the port FILE: . After installation, set its output option from Property -> Printing preferences... -> Advanced -> Postscript options -> Postscript output opion to encapsulated postscript format (eps).

This printer can be used to print the chart to an eps file.

The EPS file contains borders which defines where the chart is. Use postscript to open this EPS file, then use a text editor to open it simultaneously. Tick options -> eps clip from postscript. Then edit the line %%BoundingBox: ... from the text editor. Adjust the size of the chart in eps so that the clip fits well to the chart. Then save EPS.

Now you are done. Insert the chart into latex!

C++ note: be careful with ifstream

2006-11-14T13:14:00.000-08:00

The following is the correct and actually standard way of reading something

while(file.good())
{
file >> s;
cout << s;
}

However, the following is wrong:

while(file.good())
{
file.get(t);
cout << t ;
}

it will normally repeat the last char in the file. The reason is that file.good only changes after get() is called. This is the way

while(file.get(t))
{
cout << t ;
}

file.get(t) will return success if the process works.

C++ note: TRACE macros

2006-11-08T08:59:00.000-08:00

#ifdef DEBUG
#define TRACE(x) { cout << x << endl; cout.flush(); }
#else
#define TRACE(x)
#endif

#ifdef DEBUG
#define RUN_ON_DEBUG(x) x
#else
#define RUN_ON_DEBUG(x)
#endif

Python note: the value and the display of a unicode string

2006-10-31T07:28:00.000-08:00

Sometimes it is necessary to view the unicode encoding of a special character or to see the display of a certain unicode code. Here is some example code.

print '\xe6\x8d\xae'.decode("utf-8")
<displays the unicode character>

print repr(<the unicode character here>)
'\xe6\x8d\xae'

wxPython note: about callbacks

2006-09-29T04:17:00.000-07:00

Be careful about callbacks, for they sometimes bring unexpected logics. The process is not written explicitly in the code, and therefore may cause traps, just like aspect oriented programming. For example, I just wrote a callback from notebook page change. Then I used some manual calls to change the notebook pages. I did not notice that those manual calls also brought up callbacks, and therefore messing the logic. This problem is fixed by introducing a boolean variable bManual to indicate whether a page switch is done by pressing manually or by a function call. Whenever the notebook page is switched by function calls, it is marked with the variable.

Thinking of aspect oriented programming, sometimes a program is added with new functionalities and thus become larger all the time. Apart from using SVN to monitor the changes, it is also possible to use some special end of line comments to clarify. For example, some functionalities can be marked with # [-functionality-]. Then in further editing, we simply check the tags to find which code does the job. However, this approach should be used carefully so that all code and comments are consistent.

Python note: module subprocess provides functionalities to open arbitrary file

2006-09-28T02:55:00.000-07:00

To open an email attachment in some email client, the client needs to make new processes which opens the corresponding file. This can be done by using the subprocess module, which spawns new process and opens the file.

import subprocess
subprocess.Popen(filename, shell=True)

C++ note: about strings

2006-09-03T14:51:00.000-07:00

length - s.length() / s.size()
index - s[1] = 'x' / s[2]
slice - s.substr(1,4) means starting from 1, length 4.
append - s.append(t)
replace - s.replace(1,3, 'x') replaces slice (1,3)
erase - s.erase(1,2) same meaning
find - s.find("abc",2) find from index 2
reverse - reverse(s.begin(), s.end()) modifies strs.

It's alright concatenating strings with +
The constructor can also be s = string(t, start, length).

C++ note: int to string

2006-08-28T13:53:00.000-07:00

import <string>
import <sstream>

using namespace std;

int main() {
...string s;
...int a=1;
...stringstream ss;
...ss << a;
...ss >> s;
}

also, use atoi or strtol for string to int (cstdlib).
use s = c to assign directly from C string to string, and use s.c_str() to get c string from string

Python note: hash

2006-07-08T01:33:00.000-07:00

__hash__ provides the hash code for an object. It is used under two circumstances: when the object is put in a dictionary; or when hash() built-in function is called.

There is a requirement for this method - two objects should have the same hash when their __cmp__ returns zero (they are equal). Thus when a class does not provide __cmp__ member function, it should not provide __hash__.

VIM note: tabs

2006-07-07T07:58:00.000-07:00

In VIM 7, tab view is supported.

To open a new tab, use :tabnew
To navigate among tabs, use 'gt'
To close a tab, use ':tabclose'

Python note: unicode example (switch utf to gb2312)

2006-06-06T03:32:00.000-07:00

This is a script to switch files from unicode to gb2312

# gb2utf - switch encoding between text
# Yue Zhang 2006
import sys
iFile = open(sys.argv[1])
oFile = open(sys.argv[2], "w")
sLine = iFile.readline()
while sLine:
...try:
......uLine = sLine.decode("gb2312")
...except UnicodeDecodeError:
......sLine = iFile.readline()
......continue
...oFile.write(uLine.encode("utf8")) # note this.
...sLine = iFile.readline()
iFile.close()
oFile.close()

Python note: get your ip address

2006-05-29T03:12:00.000-07:00

Here is a small platform independent script for you to get the IP address for the current machine.

import socket
print socket.gethostbyname(socket.gethostname())

Python note: SimpleHTTPServer note

2006-05-28T13:52:00.000-07:00

Special notice for SimpleHTTPServer:

1. Read more of the source code! The SimpleHTTPRequestHandler is initialised, does the job and then dissappears. To retain it code must be edited.

2. Notice that each HTTP request asks only one response. This is HTTP protocol, and more responses will cause problems.

C++ note: references vs pointers

2006-05-23T10:03:00.000-07:00

Use references when the target is a fixed object:

a_class* const a_inst=&a; => a_class &a_inst=a;

It's ideal to use references when passing a parameter to a function, because they probably won't move. However, when using references for return values we must be careful that the original value is in the heap and not in the stack (local varaible). It's more natural to return a pointer.

Use pointers in the cases of iterating through a lot of objects. Actually, iteration is probably the best place to use pointers. Also when the address is needed explicitly pointer is the only choice.

VIM note: abbreviations

2006-05-13T02:24:00.000-07:00

Command :abbr (:ab) sets abbreviations for strings. For example, with

:abbr #a hello

You could use #a[ENTER] in the INSERT mode to write "hello". This is useful for writing comment.

In my python files, I usually use comment blocks like

#--------------------------------------------
#
# Function header
#
#--------------------------------------------

This could neatly be done by putting some abbr commands to the .vimrc file

Note:
1. You must use # plus one letter for abbreviation names
2. Under windows the vimrc file is _vimrc, and you must make an environment variable VIM.

C++ note: virtual inheritance

2006-05-10T04:07:00.000-07:00

The format

public class C: virtual B {...}

The main reason for virtual inheritance is for the diamond structure - B extends D, C extends D and A extends B, C. Without virtual mark, the instances of A will include data slots defined in both B and C, while the data slots defined in B and C will each include the data slots from D .

Python's will always have a diamond structure, because it always uses references. Of course Java does not have such problems.

Python note: when you get a lot of instances

2006-05-10T03:42:00.000-07:00

Some classes has quite a lot of instances, and it's important to reduce the memory consumption by these objects. I blog two ways of doing it by Python.

First is using __slots__. Define this in the class definition, with a sequence type (normally tuple, but never string). For example,

class C(object):
...__slots__ = "foo", "bar"

This will make the instances of the class only have two attributes "foo" and "bar". Methods are the same, and they just need to be defined in the normal way.

The reason that __slots__ might save memory is that it saves the need of making a dictionary object in every instance to store possible attributes. This works when there are a large number of instances.

The second way is the flyweight pattern. The idea of this pattern is reusing existing objects.

For example, an email client maintains many messages. Each mail could be tagged with "read", "flag" etc. One client might contain huge number of email instances viewed at a time, and it's wise to reuse certain property instances for each email.

Lastly, my view regarding patterns is that they are not something to be enjoyed as programming tips. Different problems must be solved in different ways, and applying a pattern blindly is of no good. However, reading some patterns could give me hints in problem solving. And a byproduct is that I would know what people in the Java world are talking about ;-)

Python note: a file merger

2006-05-03T13:46:00.006-07:00

Problem: I've got two folders, containing images from two Cannon camera. They were taken the same day. Unfortunately, these two cameras gave the same names to their pictures. I wanted to merge these two folders, with more powerful functionalities.

Script: This script takes in two folders, moving files from one folder to the other one. When there are duplicate file names, it compares the files. If the files are really duplicated, it only keeps one copy. If the files are different in content, they are renamed to different names by adding postfixes.

Code: The following python source
#
# merge files - merge two folders with no duplicate files
#
g_sWelcome = """
merge_files - merge files from two directories into one.

The files from the "from" directory will be moved to the "to" directory, while
duplicated files will be removed. If two files are in the same name but are
different in signature (revision time, size), the new one will be renamed.

Author: Yue Zhang, 2006
"""
import sys,os
import filecmp
import shutil
#
# Given a path, filename and extention, return a full path name without collision
#
def fileid_alloc(sPath, sPathFrom, sFileName, sExtension):
...global nDuplicateName, nDuplicateContent
...nIndex = 0
...sNewFileName = os.path.join(sPath, sFileName + sExtension)
...if os.path.exists(sNewFileName):
......nDuplicateName += 1
......if filecmp.cmp(sNewFileName, os.path.join(sPathFrom, sFileName + sExtension)):
.........nDuplicateContent += 1
.........return sNewFileName
...while os.path.exists(sNewFileName):
......nIndex += 1
......sNewFileName = os.path.join(sPath, sFileName + str(nIndex) + sExtension)
...return sNewFileName
#
# Main function
#
def merge_files(folder_from, folder_to):
...for sFullFileName in os.listdir(folder_from):
......sFileName, sExtension = os.path.splitext(sFullFileName)
......sNewFileName = fileid_alloc(folder_to, folder_from, sFileName, sExtension)
......shutil.move(os.path.join(folder_from, sFullFileName), sNewFileName)
#
# Main entry
#
if __name__ == '__main__':
...global nDuplicateName, nDuplicateContent
...nDuplicateName = 0
...nDuplicateContent = 0
...print g_sWelcome
...if len(sys.argv) != 3:
......print "Usage: merge_files.py folder_from folder_to"
......sys.exit(0)
...merge_files(sys.argv[1], sys.argv[2])
...print "In all %d duplicate file names processed, among which %d
............duplicate contents are merged and the rest are allocated new name."
............% (nDuplicateName, nDuplicateContent)

Disclaimer: I give no warranty of responsibilities of use of the code, though I have tested this code with my own photos.

VIM note: switch dos format to unix format

2006-04-30T08:46:00.000-07:00

Still the same problem as my last Python note, now I want to do it with vim.

This could be done by global pattern replacement. The command is:
:%s/pattern/replacement

The pattern needs to use literal mode: [Ctrl-v] key
In this case it's [Ctrl-v][CR], showed as ^M. The whole command will look like :%s/^M$//.

Python note: SunOS file format switching

2006-04-26T07:03:00.000-07:00

When I opened boost-jam src under SunOS, I found that each line was tailed with ^M. This is chr(13), which means that the end-of-line character for these files are \0xd\0xa.

To remove \0xd in the end-of-line character and switch files to format which SunOS reads, I wrote such a Python program.

import os
for sFile in os.listdir("."):
os.system("sed 's/%s//g' %s>TEMP && mv TEMP %s"
% (chr(13), sFile, sFile))

's/pattern/replace/g' is the general expression for string substitution with UNIX.

Python note: "?:" in Python

2006-03-14T07:48:00.000-08:00

In C++ and Java there is a handy way of writing conditional expression, such as x = y>1?1:0. However there is no ?: operator in Python.

Several ways have been suggested around this problem. Some people use "a and b or c", while others use "(a and [b] or [c])[0]". However I don't think them intuitive.

I was using dict for the expression, and to express x = y>1 ? 1 : 0, I type

x = {True : 1, False : 0}[y>1]

which is also concise.

Python note: make use of built-in space

2005-09-07T00:41:00.000-07:00

This is about the ways to make (cross module) global variables.

One way of sharing variables among runtime modules is defining a global module, and let every module import it. The global module will be loaded only once, because Python puts every loaded module into sys.modules and makes sure that it won't be executed again by import statements. Once the global module is loaded, every module could access global.xxx for variables. In this way the variables are shared as global.

The above method takes use of Python module loading mechanism to achieve global sharing. There is a more straightforward way. In Python, searching for variables follows the order of function -> module -> built-in scope. While the variable is not found anywhere in the module, the built-in scope will be looked for. This scope is defined as a global module (or dict).

Suppose we have main module:

main.py

g_nConfig = "blabla"
__builtins__.g_nConfig = g_nConfig

import first_module
import second_module

# other things to do

Then in the subsequent executions within the two imported modules, g_nConfig is accessible.

Now, suppose that there are many such global things to use. You can make a concentrated sharing for them. The easiest form could be a dict.

g_dGlobals = {'g_nConfig' : "bla bla", 'g_oObject1' : object1}

Of course, to make the global powerful, you can make it a class.

Python note: unicode

2005-08-26T01:31:00.000-07:00

When you get some error output like this:

'ascii' encoding can not encode ...

The first thing to check is python unicode object.

Python chooses a separate type of object to support unicode, in order to keep string compatibility. Thus python has two kinds of strings: str and unicode. Str objects are the same as the standard C string - an array of chars. It is used in most function calls.

Each char in a computer system can represent 128 different values. For languages like English, the alphabet is below 30. Therefore we can find a mapping between each letter and each char value. Such a mapping is called encoding. ASCII is the most common encoding to map char values into letters.

For languages with many more than 128 letters, such as Chinese and Japanese, many chars need to be combined to represent one character. A problem arises. Because different languages have different interpretations of char values, the same string can be mapped into different letters / characters by different encodings. For example, when viewing one webpage, you can switch your browser to different encodings, and the page will be displayed differently (of course there is only one encoding that is 'correct') Unicode is proposed to solve the encoding clash, and it includes all possible characters / letters in languages. Interestingly, there are also many different UTF encoding versions, include utf-8, utf-16, etc.

Unicode objects in Python are actually strings encoded in utf-8. It can be seen as the abstract representation of the real character / letters, which can be encoded into different computer strings by different encodings. In other words, if strings are viewed as the outside form, Unicode can be viewed as the inside meaning.

Unicode objects can be changed to str object by the method 'encode'. It will translate the meaning to raw strings with certain encodings.

On the contrary, raw strings can be changed to unicode, using method 'decode'. When you know the 'correct' encoding of a raw string, you can tell it to the system and make it an unicode object.

There are methods to help you determine the os encoding. They are sys.getdefaultencoding() and sys.getfilesystemencoding(). Which are self explanatory.

Some methods in python work with str while other work with Unicode. You have no difficulty with those taking both types, but you need to be careful when calling a method that take only str or Unicode params. Also, the return type of a method us often neglected. For example, file.readline() would return a string. If a file is a unicode file, it's still a string encoded in 'utf-8'.

When a unicode object is passed to a method taking string params, or vice versa, the system will try to switch beween them automatically. However because we did not specify encodings beforehand, it will use ascii by default. When the real encoding can't be interpreted by the ascii char set, the exception at the beginning of this article will occur. The steps to take to fix the problem might be: first check the type of the string, using type() method, then try to convert it to the correct type by using encode() or decode, specifying the encoding.

wxPython note: process tab end enter key events for TextCtrl in dialogs

2005-08-22T19:57:00.000-07:00

When you place a TextCtrl in a dialog and catch the Key events for it, you will find that enter and tab key events are not processed. When you press tab key, the focus will be switched to the next widget.

The solution is setting the style for the TextCtrl. There are two styles, wx.TE_PROCESS_ENTER and wx.TE_PROCESS_TAB, which default to unset. They will help in processing events.

Haskell note: turorials

2005-08-18T21:50:00.000-07:00

I am completely new to Haskell functional programming. I started to play with it simply because of the need in my MSc course. But it seems more and more interesting now.

Functional programming is quite different from "common", i.e. imperative programming, mainly in that it's not executed from the beginning to the end. A functional program can be taken as a set of equations, when calculated together yielding output.

I find this introduction succinct and helpful

http://www.haskell.org/tutorial/

Here are some good summary of the language.

About the grammar

http://www.cs.uu.nl/~afie/haskell/tourofsyntax.html

About the operators

http://www.imada.sdu.dk/~kornerup/DM22/Noter/haskell-operatorer.pdf

wxPython note: how to select many rows in Grid?

2005-08-18T21:40:00.000-07:00

This problem puzzled me some time ago, and I forgot the solution again today. Thus I feel it necessary to take it down here.

There is absolutely no way of setting a style like wx.CB_MULTIPLE to specify multiple selection here. wxGrid support multiple row selection by itself, see a reference

http://lists.wxwidgets.org/archive/wx-dev/msg21759.html

The only thing you need to have is specifying the second (hidden!) param of SelectRow - bAppend (I am vague about the name). When it's true you will see the row selected without cleaning other rows.

Of course, this implies that selecting many rows can only be done from program. Thus in order to respond to mouse and keyboard behaviors, event catching and processing are needed. Anyway, it's not uncommon to process events for a grid.

Introduction to MVC

2005-08-14T23:54:00.001-07:00

Found a good introduction to the MVC pattern.

http://csis.pace.edu/~bergin/mvc/mvcgui.html

Also see a general explanation at

http://ootips.org/mvc-pattern.html

PHP note: Difference between PHP and Python - scope

2005-07-16T18:21:00.000-07:00

Scope in Python is more complex. Firstly, functions. You will encounter local, global and builtin scopes in a function. Local scope is the scope within functions, global scope is the currently running module scope, while builtin scope is the current running python program. Secondly, objects. You will encounter object, class scope. Python searches for variables in sequence of scopes, and looks at a higer level scope when it can't find symbol in the current scope.

Scope in PHP is just simple. Normally you only need a module scope, while in functions there is a local scope. PHP does not search super scopes though. This is somehow because PHP can always find symbols. When variable not defined, PHP will simply set an empty value to it.

PHP note: Difference between PHP and Python - types

2005-07-09T03:33:00.000-07:00

PHP and Python are both interpreted languages.

Python has more strict types from PHP. Python does not have implicit type casting. For example, Python will calculate 3/2 as an integer division, and the output could be 1. The only implicit type casting that I find about Python is that Python will change integers to long integers when the value of that integer is too large.

PHP, on the other hand, does implicit type casting all the time. It does not have integer division at all. When it does 3/2 it simply yields the float result 1.5. What is more unacceptable from Python thoughts is that it turns strings to integers automatically. "15abc" + 10 = 25! The same understanding of the world applies to many other places in PHP. Such as when you meet 01081 it will be taken as 8. Because that was an octal number, which was truncated when 8 came up.

2005-07-09T03:16:00.000-07:00

Haloscan commenting and trackback have been added to this blog.