What I hate about meetings

I’m not a hater.

Meetings have their merits: we communicate information more effectively when being able to see each other; they force everybody’s attention and make sure people are in sync; and for most of us speaking and sketching is still faster than typing and drawing.

But I still hate a lot of the meetings I go to. And over time, I found bad meetings have a few things in common:

1. They are long: often times 60 minutes or longer;
2. They tend to involve more speakers, but they are less prepared (or more ad-hoc);
3. They often don’t have a clear agenda or topic; when they do, they tend to be very ambitious.

Usually you only need one of them to indicate a bad meeting (yes, it takes a lot to have a good one hour meeting, I don’t remember when was the last one for me, honestly).

Long meetings are inhuman, because humans have short attention span. Study shows the average number is 20 minutes. If you are a good speaker, you know after that you have to win your audience over again. But most meetings attendees never get that break/stimuli regularly. And what do they do? They mentally phase out. Anything that is being said afterwards probably doesn’t stand a chance of being taken out of the meeting room.

Having many people talking at a meeting is common but not always justified. With such a setting, chances are that every speaker only addresses a subset of the audience, but _everybody_ has to sit through _everything_. In systems terms, a sizable chunk of the audience are in idle cycles at any given time, which is a waste of their productivity.

Meetings without a clear goal often fail to grab people attention from the beginning; and meetings that try to achieve too much easily lose track of its course and subsequently stretch on, and on, and on… until everyone is exhausted and discussions turn into religious fights because nobody remembers what they set out to achieve in the first place.

On the contrary, the better meetings I’ve been to share a few things in common too:

1. They are shorter, sub 30 minutes is typical; and have a hard stop at the end of scheduled time;
2. They only involve the people that are absolutely necessary, and speakers make their points in concise forms;
3. They try to solve a very small number of problems only, and those problems are usually concrete.

You can see that these traits address the biggest issue of bad meetings: by making the meetings bounded in time, limited in participation and clear in scope, they improve active involvement to remove as many collective idle cycles from participants as possible, and no matter how it goes, people can always expect them to finish at a given time- you won’t feel being sucked into it forever.

Most meetings are bad because people who organize them ignore human psychology and the cost factors. As engineers, we should all know that synchronized execution, frequent interruption and chatty communication among multiple processes are usually detrimental to software efficiency. And as engineers, inefficiencies (should) sadden us. Why not carry that knowledge over to managing our daily lives?

Yes, even when I’m not in a meeting, I may not be writing code. I may be reading articles, watching funny videos on Youtube, or shopping on Amazon. But that doesn’t mean those times will be better spent in a meeting. I gain knowledge, pleasure or necessities in those experiences. I wish I could say the same to most of my meetings.

Meetings are very expensive when you do the math. Putting 10 engineers of 100k salary in a room for an hour costs you about $500. Make them worthwhile.

Programming Python with bpython – now THAT is neat!

The About page of bpython made the point clear: put what you normally get in a cumbersome IDE into a tiny package and use it in terminal. Here’s the “official” list of features:

In-line syntax highlighting.

Readline-like autocomplete with suggestions displayed as you type.

Expected parameter list.

Rewind.

Pastebin code/write to file.

Flush curses screen to stdout.

Python has always been a neat language encouraging high productivity. This tool, simple as it is, has pushed the ease of use of Python to a new level. You should definitely try it out and kudos to Bob Farrell!

Doskey: creating aliases under Windows command prompt

I’m tired of typing “ls” on an Windows command prompt and getting bounced back with an error. Aliases are truly a necessity. To simulate the behavior of “alias” on Windows, do the following:

1. Create a shortcut for cmd.exe, right-click on the shortcut and choose “properties” and proceed as follows.

2. Change the “start in” directory to your personal choice, such as “%HOMEDRIVE%%HOMEPATH%”

3. Create a batch file, such as “set_alias.bat”, in the “start in” directory. The file should contain the doskey command that loads the alias definitions. A sample file would contain this line:

doskey /MACROFILE=aliases.txt

4. Edit all your aliases.txt file, or other files that contain the Macros. For example, aliases.txt could look like this:

ls=dir $*
cp=copy $*
python2=C:\Python26\python26.exe $*
python3=C:\Python31\python31.exe $*

$* allows you to take an arbitrary number of arguments and pass that to the program (up to 9?)

5. At the end of “Target” line in the shortcut properties, add your batch script with “/K” option to run upon launching. The Target line should look similar to this:

C:\Windows\System32\cmd.exe /K set_alias.bat

Done! Now cruise along 🙂

CUDA new features (well, kinda new)

Support of broadcast in shared memory (working on half a warp each time, one to 1-16 threads).

A memo of Compute capability updates
1.0
…(PRE 8800 GTS)
1.1 atomic functions on 32-bit words in global memory
…(PRE GT200)
1.2 Atomic functions operating in shared memory, atomic functions operating on 64-bit words in global memory
1.2 Warp vote functions
1.2 16K local memory
1.2 32 active warps per SM, 1024 active threads per SM
1.3 Double precision floating-point numbers
…(Current Frontier)

LaTeX Tips from Practice (3)

How to display source code with keyword highlighting and proper comment color

Originally posted at here

Include the package needed with the following line:

\usepackage{listings}

A template of quoting source code with syntax highlighting is as follows:

\usepackage{color}
\usepackage{listings}
\definecolor{Brown}{cmyk}{0,0.81,1,0.60}
\definecolor{OliveGreen}{cmyk}{0.64,0,0.95,0.40}
\definecolor{CadetBlue}{cmyk}{0.62,0.57,0.23,0}
\begin{document}

\lstset{language=VBScript,frame=ltrb,framesep=5pt,basicstyle=\normalsize,
keywordstyle=\ttfamily\color{OliveGreen},
morekeywords={one,two,three},
commentstyle=\color{Brown},
stringstyle=\ttfamily,
showstringspaces=ture}

\begin{lstlisting}
…
\end{lstlisting}

Adjust accordingly to your preferred language, style and color.

Customize syntax highlighting for CUDA in Kate/KDevelop

CUDA is a minimal extension of C/C++ to support programming on newer NVIDIA GPUs. It introduces dozens of new keywords that are frequently used in CUDA programs. Adding syntax highlighting in KDevelop (Kate) only requires several simple steps:

1. Get keywords from “usertype.dat” provided by any Windows version of CUDA SDK, this is a text file. It should be found under $(NVIDIA_CUDA_SDK)\doc\syntax_highlighting.

2. Under your Linux account, cd ~/.kde/share/apps/katepart/syntax/, there should be two xml files regarding C/C++, cpp.xml and c.xml. Make a copy of both and name them properly, e.g. cpp_cuda.xml & c_cuda.xml.

3. Perform a replace operation on each keyword in “usertype.dat” so they match the keyword format in target xml files, and then copy them into the keyword lists of target files.

4. Modify xml header, which includes language description, file extensions and other information. You probably want to add “*.cu” to the file extension list. Remember to distinguish them from the original C/C++ language tag. Save the xml files after you are done.

5. Open Kate/KDevelop, under Tools->Highlighting->Sources you should see two new entries below C++ and C, respectively.

Enjoy.

Starting a subprocess from Python

subprocess is a convenient way to fork a new process on Windows/Unix/etc. It obsoletes previous methods such as commands (which does not support Windows) and os.system()/os.popen*/os.spawn*

Here is an example:
import subprocess
cmd_lst = ['exec_file', 'arg1', 'arg2', ...]
subprocess.call(cmd_lst) #return the value returned by the callee
subprocess.check_call(cmd_lst) #return if the callee exits with 0, otherwise raise an error


Surface by Microsoft

Happened to run into the link http://www.microsoft.com/surface, this is a product that’s been announced for over a year. Very impressive.

This somewhat proves, again, that computer science is neither about computer nor science, it is math and art.

Shot their own feet

Live Mail filtered Microsoft Survey invitation as junk. I lost a teeny-tiny chance to win in a sweepstakes. Oh well… Do we have to take training courses in “how to compose emails in a junk-unlikely style” someday in the future?

Cygwin group/passwd setting

In case anything goes wrong with user accounts, carry on the following steps:

mkpasswd -l -c > /etc/passwd

mkgroup -l -c > /etc/group

mkpasswd -d -u <username> /etc/passwd (optional)

mkgroup -d | grep <username> /etc/group (optional)