Code Storm

Officially pissed at Apple

2008-02-23T11:03:00.000-08:00

The wireless driver is fucked over in the 10.5.2 update. The airport will drop the connection to the router after a few minutes of heavy use. It sometimes lasts as long as 30 minutes but then it drops the connection. Makes trying to download large files fucking frustrating. They better fix this one fast or Linux is going onto this iMac. Did they test the update at all? You would think this driver would have seen heavy use while testing.

**UPDATE**
It seems that Apple has corrected this in the last set of updates.

Restoring Emacs layout

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

When I work in EMACS I have a specific layout that I use. I have about five frames open each dedicated to some task. One will have three dired windows and an eshell window. Others will have project files open or source files. Restoring this layout is a pain whenever I have to restart emacs. So I decided to automate this layout restoration. I found revive.el that does almost what I wanted so I wrote some code that uses revive to save the state of all the frames that are currently open and then restore that state.


(defun emacs-save-layout ();TODO: handle eshell
  "save the frame and window layout to ~/.emacs-layout. Requires revive.el."
(interactive)
(let ((out-name (concat *HOME* "/.emacs-layout"))
      (frames (frame-list))
      (configs nil)
      (buffs (sorted-buffer-list))
      (filtered-buffs nil)
      (s-buffs nil))
  (dolist (b buffs)    
      (let ((file-name (buffer-file-name b)))
        (when (and file-name
                   (> (length file-name) 0))
          (setq filtered-buffs (cons file-name filtered-buffs)))))
  (when filtered-buffs (setq filtered-buffs (reverse filtered-buffs)))
  (dolist (frame frames)
    (select-frame frame)
    (setq configs (cons (current-window-configuration-printable) configs)))
  (setq configs (cons filtered-buffs configs))
  (write-region (with-output-to-string (prin1 configs)) nil out-name)))

(defun emacs-load-layout ();TODO: handle eshell buffers.
  "Load the layout saved by emacs-save-layout. Requires revive.el."
(interactive)
(let* ((in-name (concat *HOME* "/.emacs-layout"))
      (config-count 0)
      (frames (frame-list))
      (configs nil)
      (frame-count (length frames))
      (buffs nil))
  (with-temp-buffer
    (insert-file-contents-literally in-name)
    (setq buffs (read (current-buffer)))
    (setq configs (rest buffs))
    (setq buffs (first buffs)))
  (dolist (b buffs)
    (find-file-noselect b)
    (message "Loading buffer %s" b))
  (setq config-count (length configs))
  (message "Config count is %s" config-count)
  (unless (>= frame-count config-count)
    (dotimes (i (- config-count frame-count))
      (make-frame))
    (setq frames (frame-list))
    (setq frame-count (length frames))
    (message "frame-count is %s" frame-count))
  (defun it (lconfigs lframes)
            (when (and lconfigs lframes)
              (select-frame (first lframes))
              (restore-window-configuration (first lconfigs))
              (it (rest lconfigs) (rest lframes))))
  (it configs frames)))

The Authoritarians

2007-10-15T15:18:00.000-07:00

The Authoritarians

Normally I don't enjoy political discussions or make politically oriented posts but I think, with the upcoming elections and the current climate in the United States, that more people should know about this book and an associated article. This work on authoritarianism has been done over a period of fourty years, in a manner that is very readable, and is well worth the time to read. An associated article is here.

David Rupp's Blog: The Last Language War / Language Trolling Post You'll Ever Need To Read (Hopefully)

2007-10-11T13:22:00.000-07:00

David Rupp's Blog: The Last Language War / Language Trolling Post You'll Ever Need To Read (Hopefully)

Seriously funny post. Most excellent.

elisp functions for emacs

2007-09-17T15:14:00.000-07:00

A set of functions that I use in my emacs configuration and to automate tasks. Some functions have been acquired and some I have written myself.


(defun lispdoc ()
 "searches lispdoc.com for SYMBOL, which is by default the symbol
currently under the curser"
 (interactive)
 (let* ((word-at-point (word-at-point))
        (symbol-at-point (symbol-at-point))
        (default (symbol-name symbol-at-point))
        (inp (read-from-minibuffer
              (if (or word-at-point symbol-at-point)
                  (concat "Symbol (default " default "): ")
                "Symbol (no default): "))))
   (if (and (string= inp "") (not word-at-point) (not
                                                  symbol-at-point))
       (message "you didn't enter a symbol!")
     (let ((search-type (read-from-minibuffer
                           "full-text (f) or basic (b) search (default b)? ")))
         (browse-url (concat "http://lispdoc.com?q="
                             (if (string= inp "")
                                 default
                               inp)
                             "&search="
                             (if (string-equal search-type "f")
                                 "full+text+search"
                               "basic+search")))))))

;;;======================================================================
;;; scratch buffer function to immediately go to the scratch buffer
;;; from anywhere else
;;;======================================================================
(defun scratch ()
 (interactive)
 (switch-to-buffer "*scratch*")
 (lisp-interaction-mode)
 (if current-prefix-arg
     (delete-region (point-min) (point-max))
   (goto-char (point-max))))


;;;======================================================================
;;; From: lawrence mitchell <wence-at-gmx.li>
;;; Find the function under the point in the elisp manual
;;;
;;; C-h TAB runs the command info-lookup-symbol
;;;    which is an interactive autoloaded Lisp function in `info-look'.
;;; [Arg list not available until function definition is loaded.]
;;;
;;; Display the definition of SYMBOL, as found in the relevant manual.
;;; When this command is called interactively, it reads SYMBOL from the minibuffer.
;;; In the minibuffer, use M-n to yank the default argument value
;;; into the minibuffer so you can edit it.
;;; The default symbol is the one found at point.
;;;
;;; With prefix arg a query for the symbol help mode is offered.
;;;======================================================================
(defun find-function-in-elisp-manual (function)
 (interactive
  (let ((fn (function-called-at-point))
    (enable-recursive-minibuffers t)
    val)
    (setq val
      (completing-read
       (if fn
       (format "Find function (default %s): " fn)
         "Find function: ")
       obarray 'fboundp t nil nil (symbol-name fn)))
    (list (if (equal val "")
          fn
        val))))
 (Info-goto-node "(elisp)Index")
 (condition-case err
     (progn
   (search-forward (concat "* "function":"))
   (Info-follow-nearest-node))
   (error (message "`%s' not found" function))))

;;;======================================================================
;;; Functions to insert the date, the time, and the date and time at
;;; point.  Useful for keeping records and automatically creating
;;; program headers
;;;======================================================================
(defvar insert-time-format "%H:%M"
 "*Format for \\[insert-time] (c-h f 'format-time-string' for info on how to format).")


(defvar insert-date-format "%d %b %Y"
 "*Format for \\[insert-date] (c-h f 'format-time-string' for info on how to format).")

(defun insert-time ()
 "Insert the current time according to the variable \"insert-time-format\"."
 (interactive "*")
 (insert (concat (format-time-string insert-time-format (current-time)) " ")))

(defun insert-date ()
 "Insert the current date according to the variable \"insert-date-format\"."
 (interactive "*")
 (insert (concat (format-time-string insert-date-format (current-time))" ")))

(defun insert-date-time ()
 "Insert the current date according to the variable \"insert-date-format\", then a space, then the current time according to the variable \"insert-time-format\"."
 (interactive "*")
 (progn
   (insert-date)
   (insert " ")
   (insert-time)))

(defun insert-current-file-name ()
 (interactive)
 (insert (file-name-nondirectory (buffer-file-name (current-buffer)) "\/")))

(defun insert-current-path ()
 (interactive)
 (insert (buffer-file-name (current-buffer))))


;;;======================================================================
;;; this function prints an ascii table in a new buffer 4 columns
;;;======================================================================
(defun ascii-table (&optional extended)
 "Print the ascii table (up to char 127). Given an optional argument, print up to char 255."
 (interactive "P")
 (defvar col)
 (defvar limit)
 (setq limit 255)
 (if (null extended)
     (setq limit 127))
 (setq col (/ (+ 1 limit) 4))
 (switch-to-buffer "*ASCII*")
 (erase-buffer)
 (insert (format "ASCII characters up to %d. (00 is NULL character)\n\n" limit))
 (insert " DEC OCT HEX CHAR\t\t DEC OCT HEX CHAR\t\t DEC OCT HEX CHAR\t\t DEC OCT HEX CHAR\n")
 (insert " ----------------\t\t ----------------\t\t ----------------\t\t ----------------\n")
 (let ((i 0) (right 0) (tab-width 4))
   (while (< i col)
     (setq col2 (+ i col))
     (setq col3 (+ i (* col 2)))
     (setq col4 (+ i (* col 3)))
     ; special condition to insert a <TAB> instead of an actual tab
      (cond
      ((= i 9)
       (insert (format "%4d%4o%4x  <TAB>\t\t%4d%4o%4x%4c\t\t%4d%4o%4x%4c\t\t%4d%4o%4x%4c\n"
               i i i  col2 col2 col2 col2 col3 col3 col3 col3 col4 col4 col4 col4)))
       ; special conditon to insert a <LF> instead of an actual line feed
       ((= i 10)
       (insert (format "%4d%4o%4x  <LF>\t\t%4d%4o%4x%4c\t\t%4d%4o%4x%4c\t\t%4d%4o%4x%4c\n"
               i i i  col2 col2 col2 col2 col3 col3 col3 col3 col4 col4 col4 col4)))
      (t
       ; insert the actual character
        (insert (format "%4d%4o%4x%4c>\t\t%4d%4o%4x%4c\t\t%4d%4o%4x%4c\t\t%4d%4o%4x%4c\n"
               i i i i col2 col2 col2 col2 col3 col3 col3 col3 col4 col4 col4 col4))))
     (setq i (+ i 1))))
 (beginning-of-buffer)
 (local-set-key "q" (quote bury-buffer)))

(defun explorer ()
 "Launch the windows explorer in the current directory"
 (interactive)
 (w32-shell-execute
  "open"
  "explorer"
  (concat "/e, " (convert-standard-filename default-directory))))

(defun cmd ()
 "Launch the NT Command console"
 (interactive)
   (w32-shell-execute
    "open"
    "cmd"))

(defun tomcat ()
 "launch tomcat in debug mode."
 (interactive)
 (let* ((cwd (getenv "CATALINA_HOME"))
       (tcat (concat  cwd "/bin/startdbg.bat")))
   (find-file tcat)
   (w32-shell-execute
    "open"
    tcat)
   (kill-buffer (get-file-buffer tcat))))

(defun dbg-tomcat ()
 "launch a debug console for tomcat."
 (interactive)
 (let ((dbg (concat (getenv "JAVA_HOME") "/bin/jdb.exe")))
   (w32-shell-execute
    nil
    dbg
    "-attach jdbconn")))

(defun run-cmd (cmd)
 (interactive "sCommand: ")
 (start-process cmd "*scratch*" "cmd" (concat "/c " cmd))
 (switch-to-buffer "*scratch*"))

(defun replace-all (string to-string)
 (interactive (progn (setq string (read-from-minibuffer "Replace string: "))
                     (setq to-string (read-from-minibuffer
                                      (format "Replace %s with: " string)))
                     (list string to-string)))
 "Replaces string with to-string in all buffers"
 (let ((buffs (buffer-list))
       (current-buffer (current-buffer)))
   (while (car buffs)
     (switch-to-buffer (buffer-name (car buffs)))
     (let ((pos (point)))
       (goto-char 0) 
       (query-replace string to-string)
       (goto-char pos))
     (setq buffs (cdr buffs)))
   (switch-to-buffer current-buffer)))

;;overlay bookmarks
(defun filter (fn lst)
 (let ((acc nil))
   (dolist (x lst)
     (let ((val (funcall fn x)))
       (if val (push val acc))))
   (nreverse acc)))

(defun setOverlayBookmark ()
 (interactive)
 (let*
     ((pnt (line-beginning-position))
      (ovrly (make-overlay pnt (line-end-position))))
   (overlay-put ovrly 'face 'highlight)
   (overlay-put ovrly 'pointHistory t)
   ovrly))

(defun overlayBookmarkFilterFunc (ovrly) (and (overlay-get ovrly 'pointHistory) ovrly))
(defun overlayBookmarkFilterStartsFunc (ovrly) (and (overlay-get ovrly 'pointHistory) (overlay-start ovrly)))

(defun nextOverlayBookmark ()
 (interactive)
 (let*((pnt (line-end-position))
      (ovrly_starts (or (filter 'overlayBookmarkFilterStartsFunc (overlays-in pnt (point-max)))
                  (filter 'overlayBookmarkFilterStartsFunc (overlays-in (point-min) pnt)))))
   (if ovrly_starts
       (goto-char (reduce (lambda (a b) (if (< a b) a b)) ovrly_starts))
     (message "no items in history"))))


(defun clearOverlayBookmarks ()
 (interactive)
 (let
     ((ovrlys (filter 'overlayBookmarkFilterFunc (overlays-in (point-min) (point-max)))))
   (mapcar 'delete-overlay ovrlys)
   (message "cleared point history")))

(defun toggleOverlayBookmark ()
 (interactive)
 (let
     ((ovrlys (filter 'overlayBookmarkFilterFunc (overlays-in (line-beginning-position) (line-end-position)))))
   (if ovrlys
       (mapcar 'delete-overlay ovrlys)
     (setOverlayBookmark))))

(defun overlayBookmarkRefresh ()
 "stretches the overlays from the beginning to end of a line"
 (interactive)
 (let
     ((ovrlys (filter 'overlayBookmarkFilterFunc (overlays-in (point-min) (point-max))))
      (lf (lambda (tmp) (save-excursion
                                (goto-char (overlay-start tmp))
                                (move-overlay tmp (overlay-start tmp) (line-end-position))))))
   (if ovrlys
       (mapcar lf ovrlys)
     (setPointHistory))))

;; eshell/bmk - version 0.1.2

(defun pcomplete/eshell-mode/bmk ()
 "Completion for `bmk'"
 (pcomplete-here (bookmark-all-names)))

(defun eshell/bmk (&rest args)
 "Integration between EShell and bookmarks. For usage, execute without arguments."
 (setq args (eshell-flatten-list args))
 (let ((bookmark (car args))
       filename name)
   (cond
    ((eq nil args)
     (format "Usage: bmk BOOKMARK to change directory pointed to by BOOKMARK
   or bmk . BOOKMARK to bookmark current directory in BOOKMARK.
Completion is available."))
    ((string= "." bookmark)
     ;; Store current path in EShell as a bookmark
      (if (setq name (car (cdr args)))
         (progn
           (bookmark-set name)
           (bookmark-set-filename name (eshell/pwd))
           (format "Saved current directory in bookmark %s" name))
       (error "You must enter a bookmark name")))
    (t
     ;; Assume the user wants to go to the path pointed out by a bookmark.
      (if (setq filename (cdr (car (bookmark-get-bookmark-record bookmark))))
         (if (file-directory-p filename)
             (eshell/cd filename)
            ;; TODO: Handle this better and offer to go to directory
            ;; where the file is located.
            (error "Bookmark %s points to %s which is not a directory"
                  bookmark filename)))))))

(defun eshell/start (FILE)
 "Invoke (w32-shell-execute \"Open\" FILE) and substitute slashes for backslashes"
 (w32-shell-execute "Open" (substitute ?\\ ?/ (expand-file-name FILE))))


(defun setenv-from-list (env strlst)
 "Set an environment variable using the contents of a list."
 (setenv env (join "; " strlst)))

(defun join-strings (sep &rest strngs)
 "join a bunch of strings with sep concatinated after each string."
 (let ((rslt ""))
   (dolist (str strngs)
     (setq rslt (concat rslt str sep)))
   rslt))

(defun join (sep strlst)
 "join a list of strings with sep between each."
 (let ((rslt ""))
   (dolist (str strlst)
     (setq rslt (concat rslt str sep)))
   rslt))

(defun join-ba (before after strlst)
 "join a list of strings with before and after pre/post pended to each string."
 (let ((rslt ""))
   (dolist (str strlst)
     (setq rslt (concat rslt (format "%s%s%s" before str after))))
   rslt))


;;setup load paths
(defun setup-load-paths (edir subdirlst)
 "Setup load paths. edir is the elisp directory path and subdirlst is a list of subdirectories." 
 (mapcar (lambda (subdir) (add-to-list 'load-path (concat edir subdir)))
         subdirlst)
 (add-to-list 'load-path edir))

(defun copy-to-scratch ()
 "copies selected text to the scratch buffer."
 (interactive)
 (let ((txt (buffer-substring (region-beginning) (region-end))))
   (save-current-buffer
     (set-buffer "*scratch*")
     (insert txt "\n"))))

(defun search-all-buffers (srch-str &optional match-buffers)
 "Search across all open buffers."
 (interactive "sSearch String: \nsMatch Buffers: ")
 (let (buffer-re)
   (if (stringp match-buffers)
       (setq buffer-re match-buffers)
     (setq buffer-re "."))
   (multi-occur-in-matching-buffers buffer-re srch-str t)))

(defun todo ()
 "Find all todo items in all buffers."
 (interactive)
 (multi-occur-in-matching-buffers "." "TODO: " t))

(defun multi-find-file (root-dir name-regx)
 "Find multiple files starting in root-dir and descending directories."
 (interactive "sDirectory to search from: \nsMatch files Regx: ")
 ;(message (concat "root-dir: " root-dir))
  ;(message (concat "name-regx: " name-regx))
  (if (and (and (stringp root-dir) (> (length root-dir) 0))
              (and (stringp name-regx) (> (length name-regx) 0)))
   (let ((files-to-open nil)
         (subdirs nil)
         (names-list nil))
     (setq names-list (directory-files root-dir t))
     (unless names-list (message "names-list is nil."))
     (dolist (name names-list)
       ;(message (concat "file name: " name))
        (cond
        ((file-directory-p name)  (unless (string-match "[.]+$" name) (setq subdirs (cons name subdirs))))
        ((string-match name-regx (file-name-nondirectory name)) (setq files-to-open (cons name files-to-open)))
        ))
     (dolist (item files-to-open)
       ;(message (concat "opening file " item))
        (find-file-other-window item))
     (setq file-to-open nil)
     (setq names-list nil)
     (dolist (item subdirs)
       ;(message "dropping into subdirectory.")
        (multi-find-file item name-regx)))
   (message "Need values for root-dir and name-regx.")))

Fat Dutch Guy

2007-05-08T15:10:00.000-07:00

Lets see how long this lasts

2007-05-01T14:34:00.000-07:00

The HD-DVD key. Fighting censorship.

09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0

Real life project management using Scrum

2007-01-15T14:22:00.000-08:00


Dody Gunawinata, founder of Silverkey Technologies, explaining real life project management using Scrum.

Scrum Tuning: Lessons learned from Scrum implementation at Google

2007-01-15T12:51:00.000-08:00

Google Tech Talks
December 7, 2006

ABSTRACT

Adwords introduced a Scrum implementation at Google in small steps with remarkable success. As presented at the Agile 2006 conference this exemplifies a great way to start up Scrum teams. The inventor and Co-Creator of Scrum will use this approach in building the Google Scrum implementation to describe some of the subtle aspects of Scrum along with suggested next steps that can help in distributing and scaling Scrum in a "Googly way".

Scrum et al.

2007-01-15T12:46:00.000-08:00

Google Tech Talks
September 5, 2006

Ken Schwaber co-developed the Agile process, Scrum. He is a founder of the Agile Alliance and Scrum Alliance, and signatory to the Agile Manifesto. Ken has been a software developer for over thirty years. He is an active advocate and evangelist for Agile processes.

ABSTRACT
Scrum is an amazingly simple process that causes many, many changes when it is implemented. This seminar presents the basic framework of Scrum and some of the implementation issues associated with it.

Getting Started with Common Lisp, part 2

2006-04-18T08:01:00.000-07:00

The first thing that you need to do when getting started with Common Lisp is to choose a Lisp implementation. Lisp has a standard, similar to C++. Choosing a Lisp implementation is similar to choosing a C++ compiler. Like C++ compilers, conformance to the standard varies. For this post I will only discuss Free CL implementations but there are a number of commercial CL implementations. If your lucky enough to be using Linux for development, there are quite a few Free CL implementations. You have the choice of CMUCL, SBCL, CLISP, GCL, and ECL. There are probably more but those are the ones I know of. I chose SBCL because of its speed and because ASDF comes pre-installed. (ASDF is a library management system similar to CPAN.) SBCL can produce standalone executables. If you're stuck running Windows for some reason then your choices are somewhat more limited. There is CLISP, GCL and ECL. Under windows I chose CLISP because of it's standards conformance and because there are a lot of libraries that are known to work with it. It is also very cross platform. It will pretty much run under whatever OS you want. There are also a number of interop libraries for it so you can make use of windows specific features easily. CLISP uses a VM and byte code system, similar to Java, so it is not as fast as some of the other LISPs but it is faster than Java.

Getting Started with Common Lisp, part 1

2006-04-06T20:35:00.000-07:00

I've spent the last couple of months learning Lisp. I would say the hardest part about the process has been figuring out how to get a proper development process setup and learning how to install libraries.
Lisp is a significantly different environment than any of the other languages I have learned. It's not the syntax that is the real issue. Once you get used to prefix notation and how the libraries work, you really start to appreciate the language. If you get emacs setup correctly then Lisp syntax is actually easier than the more common languages. The bug hurdle in my adjustment to Lisp was getting used to working with the repl, learning about application images, learning how to work with SLIME and learning the primary library and application management system, which is called ASDF. Once you learn how to install ASDF, getting and installing libraries becomes simple, somewhat like CPAN or Python's easyInstall. The next few posts will be about how I overcame each of these hurdles and learning to appreciate Lisp and the Lisp way.

Lisp in Python

2006-03-08T15:42:00.000-08:00

I was browsing through some Lisp sites and came across this cool article. Describes and implements a Lisp interpreter in Python. There are some other cool articles on this site as well.

A nice series of introductory Python articles

2006-02-13T10:54:00.001-08:00

This series (Part1, Part2, Part3, Part4 ) articles looks like a nice intro to Python.

Mastering Ajax, Part 2: Make asynchronous requests with JavaScript and Ajax

2006-01-22T14:42:00.000-08:00

Part 2 goes into more depth on using XMLHttpRequest. It details some basic uses like error handling and call backs. Nice article.

Mastering Ajax, Part 1: Introduction to Ajax

2006-01-22T14:09:00.000-08:00

Yet another excellent Developer Works article. A nice intro to Ajax. Covers the basics of using the XMLHttpRequest object, including cross browser issues.

Another nice Python Tutorial

2006-01-11T13:54:00.000-08:00

Nice tutorial. The color scheme is not so hot though.

Discover Python

2006-01-10T08:23:00.000-08:00

There is a nice set of introductory Python articles over on Developer works.

Planner Mode for EMACS

2005-11-09T20:08:00.000-08:00

I came across Planner mode a couple of weeks ago. It has been working very well for me. It integrates with a variety of other EMACS applications. It is also able to keep track of time spent on a given task, which is handy for a number of uses.
In the past I have used a variety of contact management/calendaring software including Outlook and Evolution but they are big and bulky and get in the way. They are also overly complicated and it is hard to associate notes with a given piece of information.

Useful web site

2005-09-21T21:09:00.000-07:00

This site has a lot of interesting articles on a number of different languages.

Very Interesting Lisp Primer

2005-08-18T16:08:00.000-07:00

It gives a very nice history and current state of Common Lisp as well as pointers to a lot of additional material. Pascal Costanza's Highly Opinionated Guide to Lisp

Find 'hidden' resources in extension DLL's

2005-08-08T22:12:00.000-07:00

While creating your new, nifty grid control for your MFC extension DLL, you put your resources into your MFC extension control. Then when you compile and run your test application, or worse, your production application, it can’t find the controls resources. A worse problem is that it silently uses the wrong resources.

Identifying the problem

The problem is that MFC assumes that all of the applications' resources reside in the main executable. There are two ways to solve this problem. The first method is to let MFC hunt for the correct resource using AfxFindResourceHandle. The second method revolves around treating the extension DLL like a separate resource DLL.

However, there are significant disadvantages to both methods. The main disadvantage with the first method, which uses AfxFindResourceHandle, is that there can’t be any duplicate resource IDs in any of your applications DLL’s. Also, this method is slower.Both occur because AfxFindResourceHandle searches the entire link chain in the application and returns the first module with a matching resource.

The primary disadvantage with the second method is that you have to explicitly get a handle to the target module; and since loading each kind of resource uses different functions, you end up with code that is almost identical for each kind of resource.

Ask MFC politely for the resource

To have MFC do all the heavy lifting, call AfxFindResourceHandle, like this:

HINSTANCE hInst;
HANDLE hIcon;
hInst = AfxFindResourceHandle(MAKEINTRESOURCE(IDI_YOURICONHERE),
RT_GROUP_ICON);
hIcon = FindResource(hInst, MAKEINTRESOURCE(IDI_YOURICONHERE),
RT_GROUP_ICON);

This will work fine--until someone adds an icon with a duplicate ID to the code base. There is one advantage to this method of loading a resource: You don’t have to know which module the resource resides in.

When something can go wrong, it will.

Being a firm believer in Murphy’s Law; I like to be as explicit as possible. So I prefer the second method of loading resources in my extension DLL’s. Although it requires a little more investment upfront, it pays off when your code goes into maintenance mode. Basically, for each kind of resource you use in your extension DLL, you’ll write a function like this:

CString LoadResString(UINT ResID, CString strModuleName)
{
TCHAR szBuffer[256];
//The module handle can be obtained in a variety of ways the
//following is the most
//straight forward
HMODULE mod = ::GetModuleHandle(strModuleName);
ASSERT(mod);
if (!mod){
AfxMessageBox(_T("GetModuleHandle failed in LoadResString."));
RaiseException(1814, 0, 0, NULL);
}
//This is where the resource actually gets loaded and will be
//different in each function
int count = LoadString(mod, ResID, szBuffer, 255);
ASSERT(count);
if (!count){
AfxMessageBox(_T("LoadString failed in LoadResString."));
RaiseException(1814, 0, 0, NULL);
}
CString rslt(szBuffer);
return rslt;
}

MFC extension DLL’s are a nice feature but because of all the legacy code that Microsoft has to support we are stuck with some “interesting” features like this problem with MFC not looking in the extension DLL for resources first. It’s an easy problem to overcome but it can give you a headache the first time you encounter it. It doesn’t help that you have to know what the problem is before you can find the answer in the documentation.

Note: Technically, there is a third method for specifying which module to load resources from. I chose not to examine it in this article because it's an even less explicit than the AfxFindResourceHandle method.

Marking an ActiveX object safe for scripting

2005-08-05T15:21:00.000-07:00

I recently ran a cross a problem where I had to create a COM component for use in Internet Exploder. In order to mark component safe for scripting you need to add the following to your Python class.

_reg_catids_ = ["{7DD95801-9882-11CF-9FA9-00AA006C42C4}"]

Now the class won't cause Internet Exporer to prompt for permission to load the component. I wonder why there is such a spyware problem? :0

Event logging the .NET way

2005-08-04T22:18:00.000-07:00

Those of you who have used the event logging API are in for a pleasant surprise. In the past, event logging required (comparatively) arduous coding. After creating an executable with specially formatted resources to be used as a message source, you had to register the message source. Then you finally got to write to the event log.

The System.Diagnostics name space contains (among other things) the event logging API. The two classes we'll focus on for reading and writing to the event log in .NET are the EventLog and the EventLogEntry classes.

Write to the event log

Writing to the event log in .NET follows the same basic procedure as using the Win32 API. First, open the event log.

//The period means this machine
EventLog log = new EventLog(“Application”, “.”, “MySource”);

Then write the event:

log.WriteEntry(“Test message”, EventLogEntryType.Information);

Read from the event log

Reading the event log the Win32 way requires you to open the log with the OpenEventLog function and retrieve a handle to the Event Log. Then you have to retrieve the EVENTLOGRECORD structure with the ReadEventLog function.

The EVENTLOGRECORD structure has both static and dynamic fields. In order to access the dynamic fields of the structure such as the message and the source, you have to treat the structure like a byte array. To make things inconsistent, you access the static fields with the dot operator like normal. Although it’s not difficult, it can be error-prone, and if you miscount bytes, you'll get access violations or bad data.

Reading the event log the .NET way is much improved. Instead of dealing with an EVENTLOGRECORD structure, you get to deal with a much safer and easier EventLogEntry class. When you create an EventLog instance pointing at a specific log, the Entries property (which is an instance of the EventLogEntryCollection class) automatically fills with EventLogEntries. You can use the following code to access the Entries collection:

foreach EventLogEntry entry in eventLog.Entries{
Console.WriteLine(entry.Source);
Console.WriteLine(entry.Message);
}

Create a custom event log

You can also create a custom event log by calling the static method CreateEventSource of the EventLog class. For example:

//Check to make sure that the source that will
//be associated with the new log doesn’t exist.
//SourceExists is also a static method
if (!EventLog.SourceExists(“MySource”){
//If MyNewLog does not exist it will be created.
EventLog.CreateEventSource(“MySource”, “MyNewLog”);
}

As the above code indicates, you can check to see if a source is registered. If the source name already exists, you could overwrite someone else’s source, creating havoc.

Compare the previous code to what you would have to do to create a custom event log with the Win32 API:

Create a message file.
Compile it using the message compiler.(Be sure to include the created resource into the resources of the message synch DLL or Executable.)
Register the message synch (which is about 100 lines of code) in the event system by creating the requisite registry entries.
Take a look at the keys under HKLM\System\CurrentControlSet\Services\EventLog in the registry.
Open and retrieve a handle to an event log.
Now you can write the custom event log.

Conclusion

As you can see, event logging the .NET way is quite easy. The only drawback is that your application has to be running on a version of Windows based on Windows NT. But since Windows XP is the new consumer OS, this issue will soon be moot.

MASTER THE MYSTERIOUS EVENTLOGRECORD

2005-08-01T21:57:00.000-07:00

When dealing with the Windows event log, a developer usually only wants to write events to the log. The Event Viewer, on the other hand, is good at displaying event log messages and lets you view, sort, or filter these messages from a local or remote machine. However, sometimes it's necessary to read events from the log. For instance, if you're dealing with end users and you want the users to be able to click on an icon and have all relevant event log entries sent to you via e-mail.

OVERVIEW

If you look at the documentation for the event-logging API, it appears that reading entries from the log is as simple as this.


       DWORD nBytesRead, nBytesMin;
       EVENTLOGRECORD record;
       HANDLE hEntry = OpenEventLog( NULL, "Application");
  
       While(ReadEventLog(hEvent, EVENTLOG_SEQUENTIAL_READ |
                          EVENTLOG_FORWARDS_READ,
                          0, &record, sizeof(EVENTLOGRECORD),
                          &nBytesRead, &nBytesMin)){
              //Do something with record
       }

READING AN EVENT

There are a number of problems with the preceding code, which stem from the fact that EVENTLOGRECORD is a dynamic structure. If you look at the documentation for EVENTLOGRECORD, you'll see the following:


typedef struct _EVENTLOGRECORD {
DWORD  Length;
DWORD  Reserved;
DWORD  RecordNumber;
DWORD  TimeGenerated;
DWORD  TimeWritten;
DWORD  EventID;
WORD   EventType;
WORD   NumStrings;
WORD   EventCategory;
WORD   ReservedFlags;
DWORD  ClosingRecordNumber;
DWORD  StringOffset;
DWORD  UserSidLength;
DWORD  UserSidOffset;
DWORD  DataLength;
DWORD  DataOffset;
//
// Then follow:
//
// TCHAR SourceName[]
// TCHAR Computername[]
// SID   UserSid
// TCHAR Strings[]
// BYTE  Data[]
// CHAR  Pad[]
// DWORD Length;
//
} EVENTLOGRECORD, *PEVENTLOGRECORD;

All of the fields in comments are just examples. Yet if you try to do something like this:


     _tcslen(record.SourceName);

you'll get a compile error. All of the fields after DataOffset are one big buffer, and you have to treat it as such to work with it. For instance, to get the length of the SourceName field, you must do the following.


        //precord is declared as a pointer to a byte buffer.
        DWORD length = _tcslen((TCHAR*)precord + 56);

The magic number 56 happens to be the total number of bytes preceding the SourceName field. So if you want to get the value of the ComputerName field, you use the following code:


        DWORD offset = 56 + _tcslen((TCHAR*)precord + 56) + 1;
        //The +1 is for the NULL byte
        DWORD length = _tcslen((TCHAR*)precord + offset)

The other major problem is that there isn't a way to tell how big the EVENTLOGRECORD is ahead of time without attempting to read it. This means you have to call ReadEventLog log twice: the first time with parameters that you know will fail and the second time with the correct parameters. If you look at the last parameter, nBytesMin, this variable will contain the number of bytes necessary to read the requested number of records. If you didn't catch that, you can read multiple records with each call to ReadEventLog. Here's some code that works:


  DWORD nBytesRead = 0;
  DWORD nBytesMin = 0;
  DWORD nBytesToRead = 0;
  BYTE *precord = NULL;
  BYTE fake[1];

  HANDLE hEntry = OpenEventLog( NULL, "Application");


  //This one fails but gives us the event record size
  ReadEventLog(hEvent, EVENTLOG_SEQUENTIAL_READ |
               EVENTLOG_FORWARDS_READ,
               0, fake, 1,&nBytesRead, &nBytesMin);

  nBytesToRead = nBytesMin;
  precord = new BYTE[nBytesToRead];
  ReadEventLog(hEvent, EVENTLOG_SEQUENTIAL_READ |
               EVENTLOG_FORWARDS_READ, 0,
               precord, nBytesToRead, &nBytesRead,
               &nBytesMin);//read one record

Now we extract some fields.

   CString SourceName(precord + 56);
   CString ComputerName(precord + 56 + SourceName.GetLength() + 1);

SUMMARY

Even though the event log API isn't the most difficult to master, it isn't well documented or obvious. Yet once you master the EVENTLOGRECORD structure, it's smooth sailing.

Hide data in thestream

2005-07-29T21:29:00.000-07:00

Streams are a facility built into NTFS that attaches metadata to files; this facility is similar to the extended attributes in an OS/2 file system. Unfortunately, using the term streams could be confusing because it's so overloaded (especially when it comes to files).

A new definition for streams

A file on an NTFS volume is composed of a primary stream and zero or more secondary streams . The primary stream is the data that you normally access, while the secondary stream(s) reside in parallel with the primary stream. Unlike the primary stream (which is unnamed), a secondary stream has a unique name. The secondary stream can hold any amount of any kind of data. However, streams are only available on the NTFS file system. So if a file with secondary streams is moved to another file system, you'll lose the secondary streams.

Secondary streams are invisible

Secondary streams are invisible to both the Windows Explorer and the console. In fact, the Explorer and the console will (incorrectly) report that the space is free. Streams are only partially implemented in Windows even though it’s been around since Windows NT 3.1. In order for the explorer to be stream aware, you need to install an Explorer add-on.

Accessing secondary streams

You can access secondary streams with the standard CreateFile, ReadFile, and WriteFile Win32 API’s or another API such as MFC’s CFile or executable that uses these functions for low-level file access. To access a secondary stream, append a colon followed by the name of the secondary stream to the file name. Stream names are case insensitive just like file names.

Here's the command’s you use when writing to the stream using the console:

echo foo > bar.txt:title

(Note about the above code: You can’t read the stream back from the console with the Type command.)

Here's the code you use when writing to the secondary stream, title, in C:

DWORD BytesWritten = 0;
const DWORD BufferLength = 3;
HANDLE hFile = CreateFile(“bar.txt:title”, GENERIC_WRITE,
0, NULL, OPEN_ALWAYS, 0, 0);
WriteFile(hFile, “foo”, BufferLength, &BytesWritten, NULL);
CloseHandle(hFile);

Here's the code you use when writing to the secondary stream in Python:

File = PrivoxyWindowOpen(“bar.txt:title”, “w”);
File.write(“foo”);

Below are some examples on reading the bar.txt:title stream. Specifically, here's code for reading the stream in C:

HANDLE hFile = CreateFile(“bar.txt:title”, GENERIC_READ, 0, NULL,
OPEN_EXISTING, 0,0);
const DWORD BufferSize = 25;
DWORD BytesRead = 0;
BYTE buffer[BufferSize];
ReadFile(hFile, buffer, BufferSize, &BytesRead, NULL);
CloseHandle(hFile);

Here's the code you use when reading the stream in Python:

file = PrivoxyWindowOpen(“bar.txt:title”, “r”)
print file.read()

The potential for misuse

If you start writing large amounts of data to secondary streams, you're going to create problems for users of the software. Even though they’ll run out of disk space, their systems will continue to report that there is free space. When you use streams in moderation, they can be invaluable tools for keeping key configuration data out of sight from the user.

But people can misuse streams. For instance, there is a potential for malicious use in worms and viruses. I don't know of any virus scanners that check secondary streams for malicious code. Like I said previously, secondary streams can store any type of data--that includes executable code. Hopefully the anti-virus companies catch this problem before hackers start using streams in their malicious code.

Update your application with BITS

2005-07-29T21:05:00.000-07:00

BITS is a new service shipped with Windows XP and later. It allows large files to be uploaded or downloaded in the background. BITS will then notify you when the transfer is complete.

What’s it good for?

Windows XP’s version of Windows update makes heavy use of BITS to download updates in the background while the user is doing other things or while the system is unattended. I would say that following Microsoft’s lead in this is the way to go. You can easily use it to automatically download updates for your apps.

In the past developers have written their own update code or just depended on the user to check the applications web site. Using BITS to update your application gives the user more control and is also more convenient. It also reassures the more paranoid user, like myself, who get nervous when they notice the application they are using keeps going out to the Internet for no apparent reason.

Making use of BITS.

The first step in using BITS is to register a job for the queue.

//make sure to include Bits.h

//error checking has been left out

HRESULT hr = 0;

IBackgroundCopyManager* TransManager = NULL;

IBackgroundCopyJob *pCopyJob = NULL;

GUID ID;

//Your threading model here

hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);

//Set the impersonation level to RPC_C_IMP_LEVEL_IMPERSONATE

hr = CoInitializeSecurity(NULL, -1, NULL, NULL,

RPC_C_AUTHN_LEVEL_CONNECT,

RPC_C_IMP_LEVEL_IMPERSONATE,

NULL, EOAC_NONE, 0);

//Create an IBackgroundCopyManager instance.

hr = CoCreateInstance(__uuidof(BackgroundCopyManager), NULL,

CLSCTX_LOCAL_SERVER,

__uuidof(IBackgroundCopyManager),

(void**) &TransManager);

hr = TransManager->CreateJob(L”DemoJob”,

BG_JOB_TYPE_DOWNLOAD,

&ID, &pCopyJob);

//Add files to the job

hr = pCopyJob->AddFile(L"http://MyServer/Path/MyFile.Ext", L"c:\\Path\\MyFile.Ext");

One limitation with BITS that I think is pretty severe is that the content on the server cannot be dynamic. So for instance you can’t specify a URL like this, http://www.myserver.com/Update.asp?CurrentVersion=1.0 and have the server give you the right version or have the server notify you that you’re up to date. One simple solution to this is to have your installer setup the new job and delete the old job. So whenever an update is installed the installer removes the old job and creates a new job pointing at the future file name.

Checking the status of a job.

There are a number of ways to check the status of a job. You could poll for the jobs status and perform some action based on the status of the job or you can register to receive a notification of when the job has succeeded or failed. You can actually go one step further and register a program to be executed when the job succeeds.

The last option probably makes the most sense for updating an application. In our example application we have the installer registering a job with BITS and also registers a program with a command line argument consisting of the job ID, to be run when the job succeeds. When our transfer job succeeds our little program runs and retrieves the job information, including the path of the installer and the program runs the installer. Walla, our application is updated.

//Continuing from previous code.

WCHAR wJobID[48];

WCHAR wParameters[257];

IBackgroundCopyJob2* pCopyJob2 = NULL;

WCHAR *wProgram = L”C:\program files\MyApp\UpdateUtil.exe”;

StringFromGUID2(ID, wJobID, 48);

wsprintf(wParameters, L"%s %s", wProgram, wJobID);

pCopyJob->QueryInterface(__uuidof(IBackgroundCopyJob2), (void**)&pCopyJob2);

hr = pCopyJob2->SetNotifyCmdLine(pProgram, wParameters);

//remember to release you COM objects

pCopyJob2->Release();

pCopyJob->Release();

TransManager->Release();

Wrap up.

One of the first useful axioms I learned when I got into this industry was, “never code what you can steal”. This isn’t exactly stealing but it’s in the same vein. The less code you write, the less code you have to test, and the less code you have to maintain.

Taking Advantage of COM with Python

2005-07-27T20:35:00.000-07:00

Microsoft's Common Object Model (COM) implements a cross-language object model.COM is the basis for most of Microsoft's recent technologies, such as WMI and Microsoft Office. COM allows you to write code in one language, like C++, and use it in another, such as Python or VB. Python is capable of both using COM objects and creating COM objects. It's been around, in one form or another, for a number of years.

Python has excellent support for COM. In fact, Python's support for COM is so good that COM can be used as a legitimate way to extend Python. If you need to write a Python extension that will be running exclusively on Windows, strongly consider using COM. COM objects can be reused, providing flexibility and reusability, as well.

To use COM in Python, you must install the Python Win32 extensions, which can be downloaded from http://sourceforge.net/projects/pywin32/. The pywin32 package comes in a nice installer package, so compiling isn't necessary.

Using a COM component

The steps for using a COM object is the same for all languages that support COM. First you must instantiate the object. The instantiation can be directly incorporated in the language like Jscript's ActiveXObject function or it can be supported via a library, like Pythons Dispatch function. The only difference between the two approaches is that with library based support you have to import the library code first. Once the object is instantiated, you can use the properties, fields and methods just like they were part of normal Python objects.

To start, run the makepy utility on the component that you intend to use. This isn't a mandatory step, but it has some nice advantages. Specifically, named constants defined in the typelib will be available to you when you import the constants class, and if you're using the PyWin IDE, you'll get intellisense for the properties and methods of the component.

The easiest way to run makepy is through the PyWin IDE. Launch PyWin, and under the tools menu, choose makepy. This opens a simple little dialog that contains a list of all the registed COM components on the system.

You can use a COM component without running the makepy utility, but you'll then have to use numeric values in place of the named constants that you normally use for parameters and such.

Using a COM component in Python is nearly as simple as using the component in VB.First you need to import the COM support module:

import win32com.client as w32c

If you ran the makepy utility on the component, then the constants class has all of the named constants defined in the typelib:

from win32com.client import constants

Once the module is imported, you can instantiate the COM component simply:

Obj = w32c.Dispatch(r"Object.name")

To instantiate a COM component, you need to know the class name of the component. You can find it in the documentation for the component or by looking in the registry for the object, if you know the GUID. However, If you run the makepy utility on the component then both the name of the component and its GUID will be listed in the generated python file.

Once you've instantiated a component, you have access to all the properties and methods of that component. For example the following code calls the load and transform methods of the MSXML control:

xmldoc = w32c.Dispatch(r"Msxml2.DOMDocument")

rval = xmldoc.load(xml)

xmldoc.transformNode(xsldoc)

The file transform.py that accompanies this article shows a complete example that demonstrates how to use the MSXML COM component. To use that example, you need to have the MSXML components installed. (MSXML is installed along with Internet Explorer, so it is usually present on most systems.)

Using COM, you can drive other applications such as Microsoft Office. For instance, Python can be combined with MS Word to create document management systems. Python COM integration is extremely powerful in this regard. On most Windows systems there are numerous COM objects installed. You can browse through them using the makepy utility. Anything that shows up in the makepy utility can be used in Python.

Creating a COM component

Let's look now at what may be the coolest part of Python's COM integration.

Python comes with a large library of modules that do not have equivalents in other languages. By using Python to create COM objects, it is easy to expose some of these modules to other languages.

Creating COM objects in other languages, such as C++, requires a lot of code and knowledge. It also requires that you be familiar with IDL, which is a seperate language. So, to create a COM object in C++, you actually must know two languages.

Contrast that to creating a COM object in Python.

class MD5Obj:

_public_methods_ = ["Update", "Hash", "Hex"]

_reg_progid_ = "Python.MD5"

_reg_clsid_ = "{895E2BD0-0DA7-11D9-9669-0800200C9A66}"

MD5 = None

def __init__ (self):

self.MD5 = md5.new()

return

def Update (self, val):

self.MD5.update(val)

return

def Hash (self):

return self.MD5.digest()

def Hex (self):

return self.MD5.hexdigest()

Notice, that there are no non-Python constructs, no IDL, and no funny preprocessor macros —just plain old Python. The code wraps the MD5 module and exposes the methods that it needs. Something else to notice is that this class does not inherit from another class some magical COM class. What makes this a COM class is the three fields, _public_methods_, _reg_progid_, and _reg_clsid_. _public_methods_ informs informs pyWin which methods you want publicly exposed. Usually you want only the methods that are part of you public interface listed in this field. _reg_progid_ is just a string that gives the object a semi-unique name, that can be used to instantiate the object. The _reg_clsid_ field is a GUID (Globally Unique ID) that is the actual unique name of the object. This is also called the class ID. The class ID can be used to instantiate an object but there are various reasons not to do this. It's better to use the program ID for this. There are a number of utilities to create GUID's available on the Internet as well as part of various development environments.

To have the COM object work in a development environment, you have to register it. The easiest way to do this is just create a little code that register's the object when the script file is run:

if __name__=='__main__':

import win32com.server.register

win32com.server.register.UseCommandLine(MD5Obj)

That's it. Just run the script and the object is registered. No seperate utility, like regsrv32, to worry about. You can't get much simpler than that.

To use the object from another language, like JScript, is just like using any other COM object.

var md5 = new ActiveXObject("Python.md5");

md5.Update("Th\is is a test");

WScript.Echo(md5.Hash());

Wscript.Echo(md5.Hex());

The full example is available in the MD5Obj.py script.

Wrapping Up

Even though this was a simple example, everything shown here holds true for complex object hiarchies. You have full access to COM's facilities. You can use attributes, read only attributes, methods, and so on. You've got access to it all as well as the full power of Python. It's all easy as (wait for it...) pie.

Consider using Python to prototype your objects before jumping into C++. This gives you the chance to evaluate your object interfaces without having to go through the build and register step each time you change something.

Who knows, you may find that there is no reason to implement the objects in C++ after all.

SIDEBAR:

Using Pyscript

Windows Common Object Model (COM) isn't the only way to integrate Python with Windows. You can also use PyScript.

PyScript integrates Python with the Windows Scripting Host (WSH), Windows' official scripting engine. WSH is interesting because it's scripting language-agnostic, and because it provides an API for adding new scripting languages to the system.

Using WSH, Python has full access many of the core Windows features, such as such as mapping drives, controlling network printers, and remote scripting. WSH also allows Python to be used in login scripts. And since WSH has poor support for creating graphical user interfaces (GUIs), Python is a nice complement. By using pyscript you get everything that the WSH provides as well as all the capabilities and just plain fun that Python provides.

Python's Win32 library has WSH integration, but it's not enabled by default. To enable pyscript you need to run the pyscript.py file. It's default location is C:\Python23\Lib\site-packages\win32comext\axscript\client\pyscript.py. Running this script simply registers Python with WSH. To create a pyscript file, use the pys extension intead of the py or pyw extensions.

(Because of the many exploits involving vbscript and WSH, the pyscript.py registration script does not enable explorer associations. Considering that many network admins are actively disabling explorer associations with .vbs and .js files, this is a smart default. If you would like to have explorer integration, I have included a reg file that will add the explorer integration for you. If you have an odd setup or use an older version of Python you will need to edit the reg file.)

The example script, example.pys, first creates an MD5 object using Python's MD5 module.

import md5

m = md5.new()

m.update("%systemroot%\\system32\\wscript.exe")

Next, it creates a link, on the desktop to the wscript.exe application. The MD5 hash is appended to the end of the link description.

WshShell = WScript.CreateObject("WScript.Shell")

Desktop = WshShell.SpecialFolders("Desktop")

link = WshShell.CreateShortcut(Desktop + "\\Wscript.lnk")

link.Description = "Link to the Windows Scripting Host" + " " + m.hexdigest()

link.IconLocation = "wscript.exe,1"

link.TargetPath = "%systemroot%\\system32\\wscript.exe"

link.Save()

2005-07-24T21:23:00.000-07:00

Here are two great books on Common lisp.

Practical Common Lisp

On Lisp

They're both available for download.

An interesting Python function for working with Subversion

2005-07-24T21:09:00.000-07:00

This is a function I wrote for working with SVN repositories. It works like os.walk.

import pysvn

"""
Utilities for working with Subversion repositories

"""


def walk (targeturl):
  """
  Walk through an subversion repository.

  """
  dirStack = []
  theEnd = 0
  client = pysvn.Client()
  client.callback_get_login = prompt
  client.callback_notify = notify
  client.callback_get_log_message = logmessage

  ls = client.ls(targeturl, recurse = False)
  files = []
  dirs = []
  for item in ls:
      if item["kind"] == pysvn.node_kind.dir:
          dirStack.append(item)
          dirs.append(endOfPath(item["name"]))
      if item["kind"] == pysvn.node_kind.file:
          files.append(item["name"])
  yield (targeturl, dirs, files)

  while len(dirStack):
      files = []
      dirs = []
      base = dirStack[theEnd]
      del dirStack[theEnd]
    
      currentDir = base["name"]
      ls = client.ls(currentDir, recurse = False)
      for item in ls:
          if item["kind"] == pysvn.node_kind.dir:
              name = endOfPath(item["name"])
              dirs.append(name)
              dirStack.append(item)
          if item["kind"] == pysvn.node_kind.file:
              name = endOfPath(item["name"])
              files.append(name)

      yield (currentDir, dirs, files)


    
  return

Obligatory first post

2005-07-24T20:47:00.000-07:00

I am a software engineer located in western Washington. I tend to use a lot of different programming languages in my development projects. Since I enjoy learning new languages, this works out well. I also enjoy experimenting with new gadgets. For instance this post is being written from an Ogo, which is a little email and IM only device.