Stupid Problems that Frustrate me

I suppose I should have mentioned it ...

Russ — Tue, 15 Aug 2006 09:57:00 GMT

I have a new blog intended to replace this one. For whatever reason, I cannot get dotText to export my posts correctly. I plan on keeping this site up for a while, but all new content is at: http://russ.unwashedmeme.com/blog.

LINQ preview and Lisp

Russ — Wed, 01 Mar 2006 11:26:00 GMT

I really wanted to be excited about .Net 2.0 and C#'s 3.0 LINQ preview. However, between .Net1.1 and .Net2 coming out, I started to play with LISP.

First, I was digging through some C# 2.0 the other day (now with Generics and "Anonymous Delegates Outer variable capture" (craptastic, hacked, statically typed closures)), and while reading a blogpost (that I lost, sorry) the blogger maid the excellent point that in removing static typing from some things (generics) they had to add reams of code. Something there should smell bad already. If you find yourself adding reams of code (and more, new syntax) to get away with leaving out half of what the language originally made you specify, maybe the language just shouldn't force you to specify that info. I dunno maybe I'm crazy and/or stupid and/or a type-ist?(someone who's against typing?).

On to LINQ: When I saw this forthcoming tech, LINQ, I thought, "Hey relational algebra-ish support inside of the language, nice". Then I looked at the demo and the only thing I can think of is all of the lisp constructs to do this sort of high end querying. All of the LISP ways that were built into the language long before its standardization (ANSI standardization: December 8, 1994) a decade ago. I am fairly sure that Ruby blocks can be put to use to accomplish this same sort of thing. Also Python list comprehensions. It really makes me question why people are willing to wait another 2-3 years for LINQ when they are a download away from better, more dynamic frameworks. Oh... right... its next to impossible to talk to sql server outside of an MS environment (vendor lockin). And as always learning anything new (that isnt ms )

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; C# Linq Demo from this .net blog
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
XDocument doc = XDocument.Load("blog.xml");
 
var d  = new Dictionary();
d.Add("2005/09","September 2005");
d.Add("2005/08","August 2005");
 
var a = new string[] { "greasemonkey", "ajax" };
 
var query =
  from
    item in doc.Descendants("item"),
    key in d.Keys,
    tag in a
  where item.Element("date").Value.Contains(key) &&
        item.Element("tags").Value.Contains(tag)
  orderby
    (string) item.Element("date") descending
  select new XElement("item",
    new XElement("month",d[key]),
    item.Element("date"),
    item.Element("title"),
    item.Element("tags"));
 
foreach (var result in query)
  Console.WriteLine(result);

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Lisp with Loop which as far as I can tell is about as close as I can get LINQ
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(mapc
 (lambda (elem) (print elem))
 
  (loop for item in doc.Decendants("items")
	for key in d.Keys
	for tag in a
	when (and
	      item
	      (find key (value (item.Element "date")))
	      (find tag (value (item.Element "tags"))))
	collect (make-instance 'XElement
			      :tag-name "month"
			      :children (list (make-instance 'XElement :tag-name "month")
					      (item.Element "date")
					      (item.Element "title")
					      (item.Element "tags")))
	into new-elems
	unless item do (return (sort new-rows #'xml-item-date-< )))  

There might be more that I am missing (for example an XML library (use ClosureXML), and a predicate that will work for the sorting he wants). About the nicest part of the LINQ stuff seems to be the OrderBy clause (also possibly GroupBy which isnt covered in the demo, but I could see being cool). However, sorting is more or less a done job given an appropriate predicate. Also there might be slightly more involved iterating going on in the query, but nothing that couldnt be handled with a modicum more code, wrapped in a macro to give it that linq-ish look, and packaged up to be useful in a week.

Could not find installable ISAM

Russ — Wed, 22 Feb 2006 13:02:00 GMT

So when trying to read from excel files we got this message repeatedly, and could not figure out what the hell it meant. We tried reinstalling some dlls that were suggested by other blog posts, but nothing would make the excel file open. Turns out, our connection string was wrong.

This is a basic correct connection string. "Provider=Microsoft.Jet.OleDb.4.0;data source=[FILE_PATH];Extended Properties=Excel 8.0;"

UPDATE: This guy knew the answer if I had read my opened tabs.

Seriously(elipsis) WTF!?!

Russ — Thu, 13 Oct 2005 14:14:00 GMT

What the hell is wrong with these people?

IE6 Error downloading PDFs over SSL

Russ — Wed, 12 Oct 2005 17:03:00 GMT

This MS page descibes the error. One thing they dont mention is a solution. They do say that:

CAUSE
This issue occurs if the server sends a "Cache-control:no-store" header or sends a "Cache-control:no-cache" header.
What they dont mention is that it isnt only the "Cache-contol" header; the "Pragma:no-cache" header also causes this problem.

A SOLUTION
Remove all of these headers, and make sure that you have the following headers set:
Response.AddHeader("Pragma","private");
Response.AddHeader("Cache-control","private, must-revalidate");

IE bug in dynamically added select options

Russ — Wed, 27 Jul 2005 17:16:00 GMT

If you add options to a select dynamically via javascript, IE will not render this correctly until you have opened and closed the select menu a few time. To get around this you just need to remove the select from the DOM then add it back. Setting the innerHTML will not help things :( Unfortunatly, setting the innerHTML causes bugs in both major browsers.

Oh Spider Monkey why doest thou keep secrets from me

Russ — Thu, 21 Jul 2005 17:46:00 GMT

There are so many hidden things inside of the javascript implementations that it is a constant frustration. I happen to like javascript an awful lot, but damn this language/environment for being so fickle.

The magic functions/properties I found are listed below. They solve one of my biggest problems with the javascript getter/setter system that Nathan wrote about here, which is that by doing what Nathan was doing, we couldn't find a way to get a reference to the actual function doing the getting/setting. I really hate that these are totally hidden.

__proto__ : a reference to the current instances prototype (deprecated in Rhino)
__defineGetter__('propName', func) : creates a getter function with the name provided as the first argument
__defineSetter__('propName', func) : creates a Setter function with the name provided as the first argument
__lookupGetter__('propName') : gets a reference to the getter function of a given property (whose name is passed as an argument)
__lookupSetter__('propName') : gets a reference to the setter function of a given property (whose name is passed as an argument)

__parent__ seems to return the scope that something is defined in, but we cant really get this to do anything reliably and its also deprecated. Nathan seems to think that this is what a closure uses to keep track of its scope.

Object Keyed Hashtable in Javascript

Russ — Wed, 06 Jul 2005 19:50:00 GMT

In the last couple days I have had the need to put keys (that are objects) into a hashtable. Since the default js hashtable only allows string keys (see my last post on this topic), I decided to check the internet. Synovic is most highly rated by google, and pretty much every other refernce to javascript hashtable points to either his implementation or notes that {key:value} creates an object/array/hashtable in javascript. Because Synovic's hashtable is just a java like wrapper around the default hashtable, his suffers from the same built in flaw that the normal hashtable suffers. I seem to be the only one with the need to hash based off objects. One of the requirements I had was that I didnt want to modify the key (which would greatly simplify the problem). If I could just add a hashcode to every object passed in as a key this whole problem again becomes trivial. The only problem is that, since objects == hashtable in javascript, I could be accidently adding things to a collection that I dont want to be modified. Also it just seems like a horrible practice to have random functions adding properties to your objects. My solution was basically to create a hash code that I could use to identify objects. Then, using that hashcode, I look into an internal string-keyed hashtable. In that value slot, I store an array of {key: objectKey, value: valPassedIn} objects. Then it is linear look up to go through the array. If I can improve the Hashcode function I can improve the overall performance of my Hashtable object, but right now I havn't a clue how to do this. and now, the moment youve all been waiting for:

Hashtable Source

Javascript Hashtable

Russ — Tue, 05 Jul 2005 16:23:00 GMT

First, I recognize that an Array is an Object is an Hashtable in javascript. The problem is that only strings can act as a key in an Object. Meaning:

 var x = new Object()  
 var y = new Object()  
>> [object Object] 
 z = new Object()  
>> [object Object] 
 x[y] = 'test' ;
>> test
 x[z]  
>> test

Since alot of the objects in javascript return [Object] as their toString(), this means that I cannot key a hashtable off objects. I guess I'll get to work writing an actual Hashtable instead of just relying on the built in stuff. I will post this when I am done. For now, off to class.

UPDATE: The Exciting Conclusion

The XBL Template / Repeater control

Russ — Sun, 10 Apr 2005 17:04:00 GMT

So I finally found a palatable solution to the Templates Problem I talked about earlier. The technique I used was to create a XBL control called 'repeater'. Ryan had some issues with the word template as I was using it so we switched over to repeater to be less ambiguous. The goal of this is not to provide a general control system (which XBL and XBLinJS try to do), but only to provide the functionality to easily repeat nodes inside of a valid tag. The best example I can give for this is for binding a dropdownlist / select box / menupopup, where I just need to repeat the <menuitem /> over a flat set of data.

var testTable = [['id', 'name'],
[ 1, 'Programmers' ],
[ 2, 'WebAdmin' ],
[ 3, 'Broadband']];

<hbox>
<repeater>
<label value="{name}" />
</repeater>
</hbox>

What the 'repeater' control does is remove the repeater node from its parent storing a reference to this 'template' on that control (so we have what was there but none of it is rendered). Then it loops through the data set adding all of the nodes that were inside of the repeater tags, with their values filled in. So what gets rendered to the page would be this:

<hbox>
<label value="Programmers" />
<label value="WebAdmin" />
<label value="Broadband" />
</hbox>

The really nice part about this system is that by inserting a repeater node inside of the template, with the outer template filling in the datasource attribute for the inner repeater as it goes, allows you to chain these repeaters to make hierarchical data repeaters. After I finish polishing everything and test it once more, I am going to port this to use <div repeater="true" > [enter repeated data here]</div> so that I can achieve the same repeater functionality in standard HTML.

Overall this has been my best experience with XBL, most notable because it required only one function block and one line of xbl content binding ( the <children /> node). It did however force me to copy code in and out of the xbl document to a standard JS doc to get parse errors to show up (Mozilla was just silently failing when their was a parse error in the XBL Javascript).

Ryan will probably give us a little preview of his js control scheme based of his interpretations of XBLinJS. What it seems we've got almost worked out is a simple way to repeat nodes and a simple way to create complex, repeatable, XUL/HTML controls. Most of this work was inspired by excessive frustration (mostly caused by nonexistant error handling) at the way mozilla handles these two things and by reading Jeremy Bowers site which convinced us to do what we already wanted to do.

UPDATE:
Go Here to see the Repeater Source
Usage Example