Xurinos

  ; [] to #()
  (defun bracket-reader (stream char)
    (declare (ignore char))
      `(vector ,@(read-delimited-list #\] stream t)))
  (set-macro-character #\[ #'bracket-reader)
  (set-syntax-from-char #\] #\))

  ; {} to hash
  (defun set-hash-values (hash pairs)
    (when pairs
      (setf (gethash (car pairs) hash) (cadr pairs))
      (set-hash-values hash (cddr pairs))))
  
  (defun in-place-hash (stream char)
    (declare (ignore char))
      `(let ((hash (make-hash-table)))
         (set-hash-values hash ',(read-delimited-list #\} stream t))
         hash))
  
  (set-macro-character #\{ #'in-place-hash)
  (set-syntax-from-char #\} #\))

http://filamentgroup.com/lab/date_range_picker_using_jquery_...

Same one? Seems to have a slick interface that does not require an apply button, does provide ranges and customizable range options, although it does not have easy keyboard input either.

An old coworker of mine had some fun advice... He said if his wife asked if some outfit made her look fat, and it did, then he would say so. He would tell her what he didn't like. As a result, he doesn't have a fat wife with ugly clothing (and he retains a wife).

I value an honest relationship, not one covered in cute little "white" lies. People who deal with me come to understand that. For them, it must be refreshing to not have to question my motivations, to wonder if I really mean what I say. And if I care about them, I am surely doing them more good by answering honestly.

Never confuse honesty with poor delivery. "Heck yeah, you look like a fat, sweaty, slobbering pig." The right words depend on your relationship. You can be sensitive to that person's needs and answer the question they really asked.

So perhaps that was a poor analogy. With regards to the exit interview, I think there is something to be said for focusing on the positive and trying to keep the emotions in check while presenting more objective responses.

It checks for the case that .innerHTML setting is not supported (I think that was for certain versions of IE) and switches to using appendChild(). I think that that small oversight is somewhat reasonable justification for using a wrapper that abstracts away the browser differences, although it can be argued that once someone understands the differences, they could just add the use cases to their code.

> I had problems reading all of this because the tin foil hat I'm wearing kept slipping down over my eyes.

From the article: "5. Sidetrack opponents with name calling and ridicule. This is also known as the primary 'attack the messenger' ploy, though other methods qualify as variants of that approach. Associate opponents with unpopular titles such as 'kooks', 'right-wing', 'liberal', 'left-wing', 'terrorists', 'conspiracy buffs', 'radicals', 'militia', 'racists', 'religious fanatics', 'sexual deviates', and so forth. This makes others shrink from support out of fear of gaining the same label, and you avoid dealing with issues."

Overall, well-done on this post.

In support, I would say that it is fairly easy, depending upon your perspective, to apply most of the various "rules" in this article to about everyone's post.

"Objects are a poor man's closures." -- Norman Adams (?)

"Closures are a poor man's objects." -- Christian Queinnec (?)

No. (What is "static" vs "loose"? :)) Procedural programming is a control flow pattern. OOP is a data arrangement pattern. You may be thinking of GUI systems with single-threaded control loops and callbacks, which is another kind of control flow pattern, but it is orthogonal to OOP. People who use OOP can, within the methods or in calls to their objects, use a procedural approach, a functional approach, and/or a callback approach. For different control flows, there are sometimes more appropriate/maintainable data arrangements.

Including Thing: http://heim.ifi.uio.no/~trygver/1979/mvc-1/1979-05-MVC.pdf

Revision: http://heim.ifi.uio.no/~trygver/1979/mvc-2/1979-12-MVC.pdf

One thing I found interesting in the blog article was the notion of "smart controls", but I can rationalize that away as another MVC module; after all, the Windows OS itself is handling all the interesting behavior, and the GUI app is borrowing the behavior. Depending on the toolkit that interfaces with the "smart controls", we get access to events (mousedown, keypress, etc) that can serve as input to one of our application's controllers.

The big epiphany for me was when I realized that the server has its own MVC, and the browser has its own MVC. The server's output is the View for the server and the Model for the browser. For a complex set of objects in a given Model, the final output of those objects is their View, and the consumer of that output uses it as a Model. In theory, any View can be a Model for the thing accepting the View, so in a complex system, you have a chain of MVCs.

And one can further imagine that applets written in JavaScript have their own MVC unit.

I work on complicated, large-data web apps sometimes daily. MVC has been a fine model for them and has kept my group's organization clean and modular.

The reality is that different people have varying strengths and weaknesses for specific tasks; people have different rates of personal development in different areas. It is not a matter of "good programmer" vs "bad programmer"; it is a matter of "That person can do that task in a better way than I can" or "That person can do that task more efficiently than I can" by some perceived measure of "better" and "efficient". The comparisons between people are relative, not absolute, and divided across many kinds of traits.

However, this article does bring up a number of traits that many of us can probably agree with as "goals to achieve in personal development". For that, it has great conversation value. Personally, I like the notion that memory might be correlated to some quality of design and output.

If I were to pick a trait of importance for a programmer, it would be "Consistently improves bottom line growth." Things that factor into that might be "Writes maintainable code" and "Knows his tools well", but it is debatable that these subtraits have a clear correlation with "bottom line growth". Has anyone actually measured these things?