The Daily WTF: Curious Perversions in Information Technology

FredSaw · 2005-11-29 Reply Admin

thenerdgod:
I could point to my first quarter Pascal project and we could all laugh at "mr. doesn't get pass-by-reference or scope, so let's make everything a global variable"

Oh, lordy, me too. Having spent the past 12 years writing programs in Basic, Assembler, and C (as a hobby) by the time I got to college, I actually argued with my professor--in class--about global variables. Oops...

FredSaw · 2005-11-29 Reply Admin

Anonymous:
There's a reason that the new (read: dumbed down) languages are so heavily represented here...

You're still coding in Cobal and Fortran, huh? Bet there's a heavy market for your skills.

2005-11-30 Reply Admin

I may be wrong, but I believe this is incorrect. I know that the anchor is considered an unsafe character to be inside of a URL string (unless you intend whatever is after it to be an anchor, obviously). I also am pretty sure that the # and whatever is after it is ignored outside the world of the browser (ie, it's dropped - but I guess it would depend on your browser). The browser itself is the only thing that depends on the anchor.

I just ran a test on my box and confirm that IE uses this behavior (can't speak for other browers though).

2005-11-30 Reply Admin

Morbii:

I may be wrong, but I believe this is incorrect. I know that the anchor is considered an unsafe character to be inside of a URL string (unless you intend whatever is after it to be an anchor, obviously). I also am pretty sure that the # and whatever is after it is ignored outside the world of the browser (ie, it's dropped - but I guess it would depend on your browser). The browser itself is the only thing that depends on the anchor.

I just ran a test on my box and confirm that IE uses this behavior (can't speak for other browers though).

This was in reply to:

"The # character is valid. It is used to point to anchors inside the HTML document. That's how to get the browser to move to a certain point inside the page when the page is loaded, instead of starting always at the top of the page."

Drak · 2005-11-30 Reply Admin

FredSaw:

Anonymous:
There's a reason that the new (read: dumbed down) languages are so heavily represented here...

You're still coding in Cobal and Fortran, huh? Bet there's a heavy market for your skills.

There's nothing wrong with VB or C# or any other language. It's just what you feel most comfortable with. The fact that more people can use the newer languages (or makes them think the can) obviously makes for more wtf code, but the real WTF is that these people get hired, not that they use VB or C# or whatever.

Drak

witch · 2005-11-30 Reply Admin

Gene Wirchenko:
Anonymous:
Damn VB or C# every time. Does no one have any LISP or FORTRAN WTFs to share?

This could be a valuable clue.

To be fair, it is also a few others. Older programming languages do not make it here too often.

Sincerely,

Gene Wirchenko

Problem would probably be that anything written in Lisp or COBOL would be a WTF to lots of people, because it can be hard to parse the language. Well, I can't speak for COBOL, but I've seen Lisp, and although I like the thought behind the language, it can be hard to read...

ammoQ · 2005-11-30 Reply Admin

witch:

Problem would probably be that anything written in Lisp or COBOL would be a WTF to lots of people, because it can be hard to parse the language. Well, I can't speak for COBOL, but I've seen Lisp, and although I like the thought behind the language, it can be hard to read...

COBOL is quite easy to read.
Insider joke:
Q: What's the name of the object-oriented version of COBOL?
A: ADD 1 TO COBOL GIVING COBOL.

ammoQ · 2005-11-30 Reply Admin

BradC:
Oh, come on. Can NOBODY see the reason for this code??

He's passing the SQL from the front end to the back end as a URL parameter. This is a poor implementation of a URLEncode.

(Generates a whole other universe of WTFs, but I think it explains it!!!)

That or the system USED TO pass the SQL inside a URL, but someone looked at the code and said "WTF??" and fixed it to be a little more secure, but didn't change all the "surrounding" helper functions.

Wait, what's wrong with passing SQL strings in user-visible URLs ??? ;)

I think you a right. This is a tripple-nested WTF: A stupid idea in general (passing SQL-statements through URLS), specified in a stupid way (encoding eliminates underscores), poorly implemented.

2005-11-30 Reply Admin

Anonymous:
Wouldn't that be: Job_Security ?

More likely it's #Job ~Security.

2005-11-30 Reply Admin

Gene Wirchenko:
Anonymous:
Damn VB or C# every time. Does no one have any LISP or FORTRAN WTFs to share?

This could be a valuable clue.

Want some fortran WTFs? I have plenty!
You have no idea what scientists are capable of when they have to write programs...
Now that I discovered this wonderful site, I might share a few.

2005-11-30 Reply Admin

BradC:
Wait, what's wrong with passing SQL strings in user-visible URLs ??? ;)

Not all that much, as long as you add a HMAC to it and verify it before using the SQL.

2005-11-30 Reply Admin

Traditional VB prior to 6.0 didn't have a string Replace method, so that explains the clumsy iteration (though it could still have been done better). As for the entire idea behind the code, though - ew.

2005-11-30 Reply Admin

That's because nobody uses them anymore. To use these old languages that would be a WTF in it self... ;-)

/H

2005-11-30 Reply Admin

The sad thing is, I've seen much worse.

2005-11-30 Reply Admin

hmm good code but when i run it i get this?????

<xsl:template name="Replace">
<xsl:param name="string" select="''"/>
<xsl:param name="pattern" select="''"/>
<xsl:param name="replacement" select="''"/>
<xsl:choose>
<xsl:when test="$pattern!='' and $string!='' and contains($string, $pattern)">
 <xsl:value-of select="substring-before($string, $pattern)"/>

 <xsl:copy-of select="$replacement"/>
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="substring-after($string, $pattern)"/>
 <xsl:with-param name="pattern" select="$pattern"/>
 <xsl:with-param name="replacement" select="$replacement"/>
 </xsl:call-template>
</xsl:when>
<xsl:otherwise>
 <xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

<xsl:template name="ReplaceLCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace"> <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/> <xsl:with-param name="pattern" select="'à'"/>
 <xsl:with-param name="replacement" select="'à'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'á"/>
 <xsl:with-param name="replacement" select="'á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'â'"/>
 <xsl:with-param name="replacement" select="'â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'è'"/>
 <xsl:with-param name="replacement" select="'è'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'é'"/>
 <xsl:with-param name="replacement" select="'é'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ê'"/>
 <xsl:with-param name="replacement" select="'ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ì'"/>
 <xsl:with-param name="replacement" select="'ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'í'"/>
 <xsl:with-param name="replacement" select="'í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'î'"/>
 <xsl:with-param name="replacement" select="'î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ò'"/>
 <xsl:with-param name="replacement" select="'ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ó'"/>
 <xsl:with-param name="replacement" select="'ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ô'"/>
 <xsl:with-param name="replacement" select="'ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ù'"/>
 <xsl:with-param name="replacement" select="'ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ú'"/>
 <xsl:with-param name="replacement" select="'ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'û'"/>
 <xsl:with-param name="replacement" select="'û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ý'"/>
 <xsl:with-param name="replacement" select="'ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'œ'"/>
 <xsl:with-param name="replacement" select="'&oelig;'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ç'"/>
 <xsl:with-param name="replacement" select="'ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'™'"/>
 <xsl:with-param name="replacement" select="'™'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'¢'"/>
 <xsl:with-param name="replacement" select="'¢'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'©'"/>
 <xsl:with-param name="replacement" select="'©'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'®'"/>
 <xsl:with-param name="replacement" select="'®'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'°'"/>
 <xsl:with-param name="replacement" select="'°'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="' '"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="''"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'·'"/>
 <xsl:with-param name="replacement" select="'·'"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="ReplaceUCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/>
 <xsl:with-param name="pattern" select="'À'"/>
 <xsl:with-param name="replacement" select="'À'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Á'"/>
 <xsl:with-param name="replacement" select="'Á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Â'"/>
 <xsl:with-param name="replacement" select="'Â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'È'"/>
 <xsl:with-param name="replacement" select="'È'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'É'"/>
 <xsl:with-param name="replacement" select="'É'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ê'"/>
 <xsl:with-param name="replacement" select="'Ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ì'"/>
 <xsl:with-param name="replacement" select="'Ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Í'"/>
 <xsl:with-param name="replacement" select="'Í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Î'"/>
 <xsl:with-param name="replacement" select="'Î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ò'"/>
 <xsl:with-param name="replacement" select="'Ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ó'"/>
 <xsl:with-param name="replacement" select="'Ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ô'"/>
 <xsl:with-param name="replacement" select="'Ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ù'"/>
 <xsl:with-param name="replacement" select="'Ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ú'"/>
 <xsl:with-param name="replacement" select="'Ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Û'"/>
 <xsl:with-param name="replacement" select="'Û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ý'"/>
 <xsl:with-param name="replacement" select="'Ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Œ'"/>
 <xsl:with-param name="replacement" select="'&OElig;'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ç'"/>
 <xsl:with-param name="replacement" select="'Ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&NBSP;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&SHY;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>
<xsl:template name="Replace">
<xsl:param name="string" select="''"/>
<xsl:param name="pattern" select="''"/>
<xsl:param name="replacement" select="''"/>
<xsl:choose>
<xsl:when test="$pattern!='' and $string!='' and contains($string, $pattern)">
 <xsl:value-of select="substring-before($string, $pattern)"/>

 <xsl:copy-of select="$replacement"/>
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="substring-after($string, $pattern)"/>
 <xsl:with-param name="pattern" select="$pattern"/>
 <xsl:with-param name="replacement" select="$replacement"/>
 </xsl:call-template>
</xsl:when>
<xsl:otherwise>
 <xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

<xsl:template name="ReplaceLCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace"> <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/> <xsl:with-param name="pattern" select="'à'"/>
 <xsl:with-param name="replacement" select="'à'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'á"/>
 <xsl:with-param name="replacement" select="'á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'â'"/>
 <xsl:with-param name="replacement" select="'â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'è'"/>
 <xsl:with-param name="replacement" select="'è'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'é'"/>
 <xsl:with-param name="replacement" select="'é'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ê'"/>
 <xsl:with-param name="replacement" select="'ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ì'"/>
 <xsl:with-param name="replacement" select="'ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'í'"/>
 <xsl:with-param name="replacement" select="'í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'î'"/>
 <xsl:with-param name="replacement" select="'î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ò'"/>
 <xsl:with-param name="replacement" select="'ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ó'"/>
 <xsl:with-param name="replacement" select="'ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ô'"/>
 <xsl:with-param name="replacement" select="'ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ù'"/>
 <xsl:with-param name="replacement" select="'ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ú'"/>
 <xsl:with-param name="replacement" select="'ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'û'"/>
 <xsl:with-param name="replacement" select="'û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ý'"/>
 <xsl:with-param name="replacement" select="'ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'œ'"/>
 <xsl:with-param name="replacement" select="'&oelig;'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ç'"/>
 <xsl:with-param name="replacement" select="'ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'™'"/>
 <xsl:with-param name="replacement" select="'™'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'¢'"/>
 <xsl:with-param name="replacement" select="'¢'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'©'"/>
 <xsl:with-param name="replacement" select="'©'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'®'"/>
 <xsl:with-param name="replacement" select="'®'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'°'"/>
 <xsl:with-param name="replacement" select="'°'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="' '"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="''"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'·'"/>
 <xsl:with-param name="replacement" select="'·'"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="ReplaceUCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/>
 <xsl:with-param name="pattern" select="'À'"/>
 <xsl:with-param name="replacement" select="'À'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Á'"/>
 <xsl:with-param name="replacement" select="'Á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Â'"/>
 <xsl:with-param name="replacement" select="'Â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'È'"/>
 <xsl:with-param name="replacement" select="'È'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'É'"/>
 <xsl:with-param name="replacement" select="'É'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ê'"/>
 <xsl:with-param name="replacement" select="'Ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ì'"/>
 <xsl:with-param name="replacement" select="'Ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Í'"/>
 <xsl:with-param name="replacement" select="'Í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Î'"/>
 <xsl:with-param name="replacement" select="'Î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ò'"/>
 <xsl:with-param name="replacement" select="'Ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ó'"/>
 <xsl:with-param name="replacement" select="'Ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ô'"/>
 <xsl:with-param name="replacement" select="'Ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ù'"/>
 <xsl:with-param name="replacement" select="'Ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ú'"/>
 <xsl:with-param name="replacement" select="'Ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Û'"/>
 <xsl:with-param name="replacement" select="'Û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ý'"/>
 <xsl:with-param name="replacement" select="'Ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Œ'"/>
 <xsl:with-param name="replacement" select="'&OElig;'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ç'"/>
 <xsl:with-param name="replacement" select="'Ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&NBSP;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&SHY;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>
<xsl:template name="Replace">
<xsl:param name="string" select="''"/>
<xsl:param name="pattern" select="''"/>
<xsl:param name="replacement" select="''"/>
<xsl:choose>
<xsl:when test="$pattern!='' and $string!='' and contains($string, $pattern)">
 <xsl:value-of select="substring-before($string, $pattern)"/>

 <xsl:copy-of select="$replacement"/>
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="substring-after($string, $pattern)"/>
 <xsl:with-param name="pattern" select="$pattern"/>
 <xsl:with-param name="replacement" select="$replacement"/>
 </xsl:call-template>
</xsl:when>
<xsl:otherwise>
 <xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

<xsl:template name="ReplaceLCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace"> <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/> <xsl:with-param name="pattern" select="'à'"/>
 <xsl:with-param name="replacement" select="'à'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'á"/>
 <xsl:with-param name="replacement" select="'á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'â'"/>
 <xsl:with-param name="replacement" select="'â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'è'"/>
 <xsl:with-param name="replacement" select="'è'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'é'"/>
 <xsl:with-param name="replacement" select="'é'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ê'"/>
 <xsl:with-param name="replacement" select="'ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ì'"/>
 <xsl:with-param name="replacement" select="'ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'í'"/>
 <xsl:with-param name="replacement" select="'í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'î'"/>
 <xsl:with-param name="replacement" select="'î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ò'"/>
 <xsl:with-param name="replacement" select="'ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ó'"/>
 <xsl:with-param name="replacement" select="'ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ô'"/>
 <xsl:with-param name="replacement" select="'ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ù'"/>
 <xsl:with-param name="replacement" select="'ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ú'"/>
 <xsl:with-param name="replacement" select="'ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'û'"/>
 <xsl:with-param name="replacement" select="'û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ý'"/>
 <xsl:with-param name="replacement" select="'ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'œ'"/>
 <xsl:with-param name="replacement" select="'&oelig;'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ç'"/>
 <xsl:with-param name="replacement" select="'ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'™'"/>
 <xsl:with-param name="replacement" select="'™'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'¢'"/>
 <xsl:with-param name="replacement" select="'¢'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'©'"/>
 <xsl:with-param name="replacement" select="'©'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'®'"/>
 <xsl:with-param name="replacement" select="'®'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'°'"/>
 <xsl:with-param name="replacement" select="'°'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="' '"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="''"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'·'"/>
 <xsl:with-param name="replacement" select="'·'"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="ReplaceUCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/>
 <xsl:with-param name="pattern" select="'À'"/>
 <xsl:with-param name="replacement" select="'À'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Á'"/>
 <xsl:with-param name="replacement" select="'Á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Â'"/>
 <xsl:with-param name="replacement" select="'Â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'È'"/>
 <xsl:with-param name="replacement" select="'È'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'É'"/>
 <xsl:with-param name="replacement" select="'É'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ê'"/>
 <xsl:with-param name="replacement" select="'Ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ì'"/>
 <xsl:with-param name="replacement" select="'Ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Í'"/>
 <xsl:with-param name="replacement" select="'Í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Î'"/>
 <xsl:with-param name="replacement" select="'Î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ò'"/>
 <xsl:with-param name="replacement" select="'Ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ó'"/>
 <xsl:with-param name="replacement" select="'Ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ô'"/>
 <xsl:with-param name="replacement" select="'Ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ù'"/>
 <xsl:with-param name="replacement" select="'Ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ú'"/>
 <xsl:with-param name="replacement" select="'Ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Û'"/>
 <xsl:with-param name="replacement" select="'Û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ý'"/>
 <xsl:with-param name="replacement" select="'Ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Œ'"/>
 <xsl:with-param name="replacement" select="'&OElig;'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ç'"/>
 <xsl:with-param name="replacement" select="'Ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&NBSP;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&SHY;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>
i wunder y

2005-11-30 Reply Admin

Impressive.

I am assuming you don't have a job...

2005-11-30 Reply Admin

Anonymous:
hmm good code but when i run it i get this?????

<xsl:template name="Replace">
<xsl:param name="string" select="''"/>
<xsl:param name="pattern" select="''"/>
<xsl:param name="replacement" select="''"/>
<xsl:choose>
<xsl:when test="$pattern!='' and $string!='' and contains($string, $pattern)">
 <xsl:value-of select="substring-before($string, $pattern)"/>

 <xsl:copy-of select="$replacement"/>
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="substring-after($string, $pattern)"/>
 <xsl:with-param name="pattern" select="$pattern"/>
 <xsl:with-param name="replacement" select="$replacement"/>
 </xsl:call-template>
</xsl:when>
<xsl:otherwise>
 <xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

<xsl:template name="ReplaceLCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace"> <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/> <xsl:with-param name="pattern" select="'à'"/>
 <xsl:with-param name="replacement" select="'à'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'á"/>
 <xsl:with-param name="replacement" select="'á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'â'"/>
 <xsl:with-param name="replacement" select="'â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'è'"/>
 <xsl:with-param name="replacement" select="'è'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'é'"/>
 <xsl:with-param name="replacement" select="'é'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ê'"/>
 <xsl:with-param name="replacement" select="'ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ì'"/>
 <xsl:with-param name="replacement" select="'ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'í'"/>
 <xsl:with-param name="replacement" select="'í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'î'"/>
 <xsl:with-param name="replacement" select="'î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ò'"/>
 <xsl:with-param name="replacement" select="'ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ó'"/>
 <xsl:with-param name="replacement" select="'ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ô'"/>
 <xsl:with-param name="replacement" select="'ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ù'"/>
 <xsl:with-param name="replacement" select="'ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ú'"/>
 <xsl:with-param name="replacement" select="'ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'û'"/>
 <xsl:with-param name="replacement" select="'û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ý'"/>
 <xsl:with-param name="replacement" select="'ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'œ'"/>
 <xsl:with-param name="replacement" select="'œ'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ç'"/>
 <xsl:with-param name="replacement" select="'ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'™'"/>
 <xsl:with-param name="replacement" select="'™'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'¢'"/>
 <xsl:with-param name="replacement" select="'¢'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'©'"/>
 <xsl:with-param name="replacement" select="'©'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'®'"/>
 <xsl:with-param name="replacement" select="'®'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'°'"/>
 <xsl:with-param name="replacement" select="'°'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="' '"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="''"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'·'"/>
 <xsl:with-param name="replacement" select="'·'"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="ReplaceUCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/>
 <xsl:with-param name="pattern" select="'À'"/>
 <xsl:with-param name="replacement" select="'À'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Á'"/>
 <xsl:with-param name="replacement" select="'Á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Â'"/>
 <xsl:with-param name="replacement" select="'Â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'È'"/>
 <xsl:with-param name="replacement" select="'È'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'É'"/>
 <xsl:with-param name="replacement" select="'É'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ê'"/>
 <xsl:with-param name="replacement" select="'Ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ì'"/>
 <xsl:with-param name="replacement" select="'Ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Í'"/>
 <xsl:with-param name="replacement" select="'Í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Î'"/>
 <xsl:with-param name="replacement" select="'Î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ò'"/>
 <xsl:with-param name="replacement" select="'Ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ó'"/>
 <xsl:with-param name="replacement" select="'Ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ô'"/>
 <xsl:with-param name="replacement" select="'Ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ù'"/>
 <xsl:with-param name="replacement" select="'Ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ú'"/>
 <xsl:with-param name="replacement" select="'Ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Û'"/>
 <xsl:with-param name="replacement" select="'Û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ý'"/>
 <xsl:with-param name="replacement" select="'Ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Œ'"/>
 <xsl:with-param name="replacement" select="'Œ'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ç'"/>
 <xsl:with-param name="replacement" select="'Ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&NBSP;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&SHY;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>
<xsl:template name="Replace">
<xsl:param name="string" select="''"/>
<xsl:param name="pattern" select="''"/>
<xsl:param name="replacement" select="''"/>
<xsl:choose>
<xsl:when test="$pattern!='' and $string!='' and contains($string, $pattern)">
 <xsl:value-of select="substring-before($string, $pattern)"/>

 <xsl:copy-of select="$replacement"/>
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="substring-after($string, $pattern)"/>
 <xsl:with-param name="pattern" select="$pattern"/>
 <xsl:with-param name="replacement" select="$replacement"/>
 </xsl:call-template>
</xsl:when>
<xsl:otherwise>
 <xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

<xsl:template name="ReplaceLCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace"> <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/> <xsl:with-param name="pattern" select="'à'"/>
 <xsl:with-param name="replacement" select="'à'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'á"/>
 <xsl:with-param name="replacement" select="'á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'â'"/>
 <xsl:with-param name="replacement" select="'â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'è'"/>
 <xsl:with-param name="replacement" select="'è'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'é'"/>
 <xsl:with-param name="replacement" select="'é'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ê'"/>
 <xsl:with-param name="replacement" select="'ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ì'"/>
 <xsl:with-param name="replacement" select="'ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'í'"/>
 <xsl:with-param name="replacement" select="'í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'î'"/>
 <xsl:with-param name="replacement" select="'î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ò'"/>
 <xsl:with-param name="replacement" select="'ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ó'"/>
 <xsl:with-param name="replacement" select="'ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ô'"/>
 <xsl:with-param name="replacement" select="'ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ù'"/>
 <xsl:with-param name="replacement" select="'ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ú'"/>
 <xsl:with-param name="replacement" select="'ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'û'"/>
 <xsl:with-param name="replacement" select="'û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ý'"/>
 <xsl:with-param name="replacement" select="'ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'œ'"/>
 <xsl:with-param name="replacement" select="'œ'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ç'"/>
 <xsl:with-param name="replacement" select="'ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'™'"/>
 <xsl:with-param name="replacement" select="'™'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'¢'"/>
 <xsl:with-param name="replacement" select="'¢'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'©'"/>
 <xsl:with-param name="replacement" select="'©'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'®'"/>
 <xsl:with-param name="replacement" select="'®'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'°'"/>
 <xsl:with-param name="replacement" select="'°'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="' '"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="''"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'·'"/>
 <xsl:with-param name="replacement" select="'·'"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="ReplaceUCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/>
 <xsl:with-param name="pattern" select="'À'"/>
 <xsl:with-param name="replacement" select="'À'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Á'"/>
 <xsl:with-param name="replacement" select="'Á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Â'"/>
 <xsl:with-param name="replacement" select="'Â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'È'"/>
 <xsl:with-param name="replacement" select="'È'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'É'"/>
 <xsl:with-param name="replacement" select="'É'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ê'"/>
 <xsl:with-param name="replacement" select="'Ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ì'"/>
 <xsl:with-param name="replacement" select="'Ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Í'"/>
 <xsl:with-param name="replacement" select="'Í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Î'"/>
 <xsl:with-param name="replacement" select="'Î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ò'"/>
 <xsl:with-param name="replacement" select="'Ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ó'"/>
 <xsl:with-param name="replacement" select="'Ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ô'"/>
 <xsl:with-param name="replacement" select="'Ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ù'"/>
 <xsl:with-param name="replacement" select="'Ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ú'"/>
 <xsl:with-param name="replacement" select="'Ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Û'"/>
 <xsl:with-param name="replacement" select="'Û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ý'"/>
 <xsl:with-param name="replacement" select="'Ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Œ'"/>
 <xsl:with-param name="replacement" select="'Œ'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ç'"/>
 <xsl:with-param name="replacement" select="'Ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&NBSP;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&SHY;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>
<xsl:template name="Replace">
<xsl:param name="string" select="''"/>
<xsl:param name="pattern" select="''"/>
<xsl:param name="replacement" select="''"/>
<xsl:choose>
<xsl:when test="$pattern!='' and $string!='' and contains($string, $pattern)">
 <xsl:value-of select="substring-before($string, $pattern)"/>

 <xsl:copy-of select="$replacement"/>
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="substring-after($string, $pattern)"/>
 <xsl:with-param name="pattern" select="$pattern"/>
 <xsl:with-param name="replacement" select="$replacement"/>
 </xsl:call-template>
</xsl:when>
<xsl:otherwise>
 <xsl:value-of select="$string"/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

<xsl:template name="ReplaceLCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace"> <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/> <xsl:with-param name="pattern" select="'à'"/>
 <xsl:with-param name="replacement" select="'à'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'á"/>
 <xsl:with-param name="replacement" select="'á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'â'"/>
 <xsl:with-param name="replacement" select="'â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'è'"/>
 <xsl:with-param name="replacement" select="'è'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'é'"/>
 <xsl:with-param name="replacement" select="'é'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ê'"/>
 <xsl:with-param name="replacement" select="'ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ì'"/>
 <xsl:with-param name="replacement" select="'ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'í'"/>
 <xsl:with-param name="replacement" select="'í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'î'"/>
 <xsl:with-param name="replacement" select="'î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ò'"/>
 <xsl:with-param name="replacement" select="'ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ó'"/>
 <xsl:with-param name="replacement" select="'ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ô'"/>
 <xsl:with-param name="replacement" select="'ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ù'"/>
 <xsl:with-param name="replacement" select="'ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ú'"/>
 <xsl:with-param name="replacement" select="'ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'û'"/>
 <xsl:with-param name="replacement" select="'û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ý'"/>
 <xsl:with-param name="replacement" select="'ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'œ'"/>
 <xsl:with-param name="replacement" select="'œ'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'ç'"/>
 <xsl:with-param name="replacement" select="'ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'™'"/>
 <xsl:with-param name="replacement" select="'™'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'¢'"/>
 <xsl:with-param name="replacement" select="'¢'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'©'"/>
 <xsl:with-param name="replacement" select="'©'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'®'"/>
 <xsl:with-param name="replacement" select="'®'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'°'"/>
 <xsl:with-param name="replacement" select="'°'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="' '"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="''"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'·'"/>
 <xsl:with-param name="replacement" select="'·'"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>

<xsl:template name="ReplaceUCWithHTML">
 <xsl:param name="input" select="''"/>
 <xsl:choose>
 <xsl:when test="$input!=''">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string">
 <xsl:call-template name="Replace">
 <xsl:with-param name="string" select="$input"/>
 <xsl:with-param name="pattern" select="'À'"/>
 <xsl:with-param name="replacement" select="'À'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Á'"/>
 <xsl:with-param name="replacement" select="'Á'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Â'"/>
 <xsl:with-param name="replacement" select="'Â'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'È'"/>
 <xsl:with-param name="replacement" select="'È'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'É'"/>
 <xsl:with-param name="replacement" select="'É'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ê'"/>
 <xsl:with-param name="replacement" select="'Ê'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ì'"/>
 <xsl:with-param name="replacement" select="'Ì'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Í'"/>
 <xsl:with-param name="replacement" select="'Í'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Î'"/>
 <xsl:with-param name="replacement" select="'Î'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ò'"/>
 <xsl:with-param name="replacement" select="'Ò'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ó'"/>
 <xsl:with-param name="replacement" select="'Ó'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ô'"/>
 <xsl:with-param name="replacement" select="'Ô'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ù'"/>
 <xsl:with-param name="replacement" select="'Ù'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ú'"/>
 <xsl:with-param name="replacement" select="'Ú'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Û'"/>
 <xsl:with-param name="replacement" select="'Û'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ý'"/>
 <xsl:with-param name="replacement" select="'Ý'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Œ'"/>
 <xsl:with-param name="replacement" select="'Œ'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'Ç'"/>
 <xsl:with-param name="replacement" select="'Ç'"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&NBSP;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:with-param>
 <xsl:with-param name="pattern" select="'&SHY;'"/>
 <xsl:with-param name="replacement" select="' '"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of select="$input"/>
 </xsl:otherwise>
 </xsl:choose>
</xsl:template>
i wunder y

And I KNOW that you don't have a job

Mung Kee · 2005-11-30 Reply Admin

It's like yin and yang. Without fncSetSQL, to produce bad SQL, there is no fncFixSQL, to fix it.
--------
This philoso-faux-cal thought is dedicated to Pat Morita (aka Mr. Kesuke Miyagi) R.I.P.

Ciaran · 2005-11-30 Reply Admin

Enric Naval:
Ciaran:
Anonymous:
I love this code, and for those believing that this is an URL-decoder, whaa? There are no # in urls, and _ are _ not " ".

... maybe something translates this somewhere, I use PHP.

That's the point, I think. The "set" function replaces "#" and " " characters - neither of which are valid in URLs - with "~" and "_". "Fix"ing the SQL does the opposite. Well, except that it mangles your other _ and ~ characters, of course.

Not trying to defend this WTF, just replying.

The # character is valid. It is used to point to anchors inside the HTML document...

The # character is not valid in an URL. It's valid in a URI to reference a fragment wthin the specified URL, but not in an URL itself. (see http://www.faqs.org/rfcs/rfc1738.html and http://www.faqs.org/rfcs/rfc3986.html )

Sorry to be specification-lawyering here, but there's a difference. What I said was perfectly correct, and if you were to convert SQL using that encoder, you might probably get a usable URL, if there weren't any other invalid characters. On the other hand, not converting the # character would not give a valid URL if the character was used in the SQL, and would cause the browser to truncate the URL to before the # character, resulting in an incomplete SQL statement.

Ciaran · 2005-11-30 Reply Admin

Crap. Sorry about what seems to be a big A tag there or something. I'm not editing it as I've heard the quote boxes will go wonky if you do that.

masklinn · 2005-11-30 Reply Admin

Ciaran:
Crap. Sorry about what seems to be a big A tag there or something. I'm not editing it as I've heard the quote boxes will go wonky if you do that.

You shouldn't worry about that since you do not, in fact, have the ability to edit you posts (the edit button never yields more than an error)

Gene Wirchenko · 2005-11-30 Reply Admin

witch:
Problem would probably be that anything written in Lisp or COBOL would be a WTF to lots of people, because it can be hard to parse the language. Well, I can't speak for COBOL, but I've seen Lisp, and although I like the thought behind the language, it can be hard to read...

If you can not read a program, that does not make it a WTF. It could be an excellent program. Calling it a WTF because you can not read it is a WTF itself.

Hard to parse? Much of COBOL is very English-like.

BTW, COBOL's EVALUATE beats C et al's switch handily.

Sincerely,

Gene Wirchenko

Gene Wirchenko · 2005-11-30 Reply Admin

ammoQ:
witch:

Problem would probably be that anything written in Lisp or COBOL would be a WTF to lots of people, because it can be hard to parse the language. Well, I can't speak for COBOL, but I've seen Lisp, and although I like the thought behind the language, it can be hard to read...

COBOL is quite easy to read.
Insider joke:
Q: What's the name of the object-oriented version of COBOL?
A: ADD 1 TO COBOL GIVING COBOL.

I prefer the version COBOL-POST-INCREMENTED-BY-1 as it is a valid COBOL name.

I have seen a manual for an OO COBOL. If a high-level assembler can be extended into OO, why not COBOL? (C -> C++)

Sincerely,

Gene Wirchenko

Gene Wirchenko · 2005-11-30 Reply Admin

Anonymous:
That's because nobody uses them anymore. To use these old languages that would be a WTF in it self... ;-)

Nah, we just do not feel we have to brag about it. We just quietly get the job done.

You have probably heard cases of people who are much better at bragging about how good they are at programming than at programming. Those of us who program in older languages usually are not that type.

Sincerely,

Gene Wirchenko

2005-11-30 Reply Admin

Anonymous:
Impressive.

I am assuming you don't have a job...

Lol. I do have a job. Tutoring beginning-level CS classes. Which means biology majors trying to take Intro to Computer Science and Data Structures classes in order to satisfy their major requirement - and let me tell you, I see code much worse than this ;). Though of course it wouldn't be fair to submit anything of theirs to wtf since they will (god I hope not, pleasepleaseplease) never actually have to write any *real* code...

Btw, the code I posted works as long as you add a 'Dim intSave' to the putItIn method (last minute edit - was a mistake). And add the appropriate Left() and Right() methods to return substrings. And use only strings with "#" and " " characters (not "~" and "_" characters) to begin with. Thought I would keep to the original (*ahem*) programmer's level of usability;)

Manni · 2005-11-30 Reply Admin

smithy 953 and Impressive:

...a lot of unnecessary stuff

If I ever meet either of you in the street, I'll have my "Killing Stick" with me and I will beat you senseless. Smithy was stupid enough to make his post absurdly large, and Impressive was even further down the mental retardation scale by including all of that crap in his weak-ass attempt to berate smithy's intelligence. Both of you are fired. So very very fired.

Xepol · 2005-11-30 Reply Admin

Rick:
Anonymous:
Anonymous:
One word: Job Security

That's two words.

Its only one word after processing it with fncSetSQL.

war and peace is only 1 word after processing it with fncSetSQL...

2005-11-30 Reply Admin

I didn't need to look further than the first two lines to know that this code is doomed. Hungarian notation, the notation for the belt-suspender-and-diaper wearing kindergarden programmers.

2005-11-30 Reply Admin

Anonymous:
You guys have it all wrong. The original *ahem* programmer meant to do this:
....

Function andThatsWhatItsAllAbout(ByVal rightFoot, ByVal leftFoot, ByVal rightHand, ByVal leftHand, ByVal rightSide, ByVal leftSide)

Dim wholeSelf = ""

rightFoot = putItIn(rightFoot)

rightFoot = putItOut(rightFoot)

rightFoot = putItIn(rightFoot)

rightFoot = shakeItAllAbout(rightFoot)

wholeSelf = doTheHokeyPokey(wholeSelf, rightFoot)

wholeSelf = turnYourselfAround(wholeSelf)

 

leftFoot = putItIn(leftFoot)

leftFoot = putItOut(leftFoot)

leftFoot = putItIn(leftFoot)

leftFoot = shakeItAllAbout(leftFoot)

wholeSelf = doTheHokeyPokey(wholeSelf, leftFoot)

wholeSelf = turnYourselfAround(wholeSelf)

 

rightHand = putItIn(rightHand)

rightHand = putItOut(rightHand)

rightHand = putItIn(rightHand)

rightHand = shakeItAllAbout(rightHand)

wholeSelf = doTheHokeyPokey(wholeSelf, rightHand)

wholeSelf = turnYourselfAround(wholeSelf)

 

leftHand = putItIn(leftHand)

leftHand = putItOut(leftHand)

leftHand = putItIn(leftHand)

leftHand = shakeItAllAbout(leftHand)

wholeSelf = doTheHokeyPokey(wholeSelf, leftHand)

wholeSelf = turnYourselfAround(wholeSelf)

 

rightSide = putItIn(rightSide)

rightSide = putItOut(rightSide)

rightSide = putItIn(rightSide)

rightSide = shakeItAllAbout(rightSide)

wholeSelf = doTheHokeyPokey(wholeSelf, rightSide)

wholeSelf = turnYourselfAround(wholeSelf)

 

leftSide = putItIn(leftSide)

leftSide = putItOut(leftSide)

leftSide = putItIn(leftSide)

leftSide = shakeItAllAbout(leftSide)

wholeSelf = doTheHokeyPokey(wholeSelf, leftSide)

wholeSelf = turnYourselfAround(wholeSelf)

 

wholeSelf = putItIn(wholeSelf)

wholeSelf = putItOut(wholeSelf)

wholeSelf = putItIn(wholeSelf)

wholeSelf = shakeItAllAbout(wholeSelf)

wholeSelf = doTheHokeyPokey("", wholeSelf)

wholeSelf = turnYourselfAround(wholeSelf)
 
'And that's what it's all about!
 
End Function

Sorry for the length of this post and especially if it does not format correctly (first timer here) but I couldn't resist ;)

Y

lol. I applaud the effort it took to pull this off!

2005-11-30 Reply Admin

Anonymous:
There's a reason that the new (read: dumbed down) languages are so heavily represented here...

Students 'learning' how to 'program'...... in VB.NET. It makes my teeth ache... grrrr. Ok, so I learned with JAVA, which, granted, isn't that much better. So I have trouble with memory leaks in C & C++ - rather like learning to drive an automatic before learning to drive a stick shift. Still, at least I used (use) textpad and a command-line compiler, rather than an IDE that completed my functions automatically for me!

masklinn · 2005-12-01 Reply Admin

Anonymous:
Anonymous:
There's a reason that the new (read: dumbed down) languages are so heavily represented here...

Students 'learning' how to 'program'...... in VB.NET. It makes my teeth ache... grrrr. Ok, so I learned with JAVA, which, granted, isn't that much better. So I have trouble with memory leaks in C & C++ - rather like learning to drive an automatic before learning to drive a stick shift. Still, at least I used (use) textpad and a command-line compiler, rather than an IDE that completed my functions automatically for me!

C++ is a notoriously awfully crappy language for teaching CS. C is too although slightly better, and Java is probably in between (much worse than C, better than C++).

Why, you ask? Because in these 3 cases you have to teach the students half the language before they even get the ability to be write/understand a (working) line of code.

2005-12-01 Reply Admin

masklinn:
Anonymous:

Anonymous:
There's a reason that the new (read: dumbed down) languages are so heavily represented here...

Students 'learning' how to 'program'...... in VB.NET. It makes my teeth ache... grrrr. Ok, so I learned with JAVA, which, granted, isn't that much better. So I have trouble with memory leaks in C & C++ - rather like learning to drive an automatic before learning to drive a stick shift. Still, at least I used (use) textpad and a command-line compiler, rather than an IDE that completed my functions automatically for me!

C++ is a notoriously awfully crappy language for teaching CS. C is too although slightly better, and Java is probably in between (much worse than C, better than C++).

Why, you ask? Because in these 3 cases you have to teach the students half the language before they even get the ability to be write/understand a (working) line of code.

I suppose that my problem is not so much with whatever particular language a student learns to program in. I mean, you gotta pick one, and yea, you gotta learn the syntax, before you can understand how/what/why to code. My problem is with learning on any IDE that completes statements, loops, functions, subroutines, method calls... etc. for you. How is a student supposed to learn how to program when everything is done automagically for them? I don't know how anybody else learned how to program, but I learned painstakingly, through trial and error. If I forgot a curly bracket I had to figure out exactly where I was missing the bracket before I could proceed. If I forgot to initialize a variable then the complier complained. And don't even get me started on how many NullPointerExceptions I have had to track down! The point is, I had to think about each and every character I typed into my code - now, given the API for just about any language, I can churn out fairly respectible (if not beautifully elegant) code most of the time - regardless of the specifics of that particular language. Whereas, I have seen a student in front of my own eyes double-click on a button in the design view of .NET and write horribly-written code inside the automagically generated subroutine, then stare at me with a blank look on his face when I said, ok, now write a separate subroutine to do <THIS>. He had absolutely no idea what a subroutine was, or how to create one to do a specific action, or why you would even need another subroutine or function to perform a particular task. Whew... ok, off my soapbox. To be fair, this student was not a CS major and it was his first (and probably only) CS class - but in my humble opinion, no student should be allowed to use an IDE until at least their second year... ;)

2005-12-01 Reply Admin

Anonymous:
[...] no student should be allowed to use an IDE until at least their second year... ;)

Strike that - make them all learn in assembly language. On computers with 64K of memory. Mwahahahahaha! (kidding, of course... mostly, anyway ;).

Gene Wirchenko · 2005-12-01 Reply Admin

Anonymous:
Anonymous:
[...] no student should be allowed to use an IDE until at least their second year... ;)

Strike that - make them all learn in assembly language. On computers with 64K of memory. Mwahahahahaha! (kidding, of course... mostly, anyway ;).

I am not though. I have given a fair amount of thought to how people learn to program and how they should.

Assembler is good because it gives a sense of how the machine actually works.

Constraints, such as low memory, help to illustrate trade-offs and why/when you make them. This is part of design.

There may be other ways to do it, but underlying knowledge and the ability to design are very useful and necessary skills for competent software creators.

Sincerely,

Gene Wirchenko

2005-12-01 Reply Admin

Oh, wait - it must have been run thru some function to "fix' the statement!

That should have read "Job_Security".

Argh...

ennuija · 2005-12-01 Reply Admin

Gene Wirchenko:
Anonymous:
Anonymous:
[...] no student should be allowed to use an IDE until at least their second year... ;)

Strike that - make them all learn in assembly language. On computers with 64K of memory. Mwahahahahaha! (kidding, of course... mostly, anyway ;).

I am not though. I have given a fair amount of thought to how people learn to program and how they should.

Assembler is good because it gives a sense of how the machine actually works.

Constraints, such as low memory, help to illustrate trade-offs and why/when you make them. This is part of design.

There may be other ways to do it, but underlying knowledge and the ability to design are very useful and necessary skills for competent software creators.

Sincerely,

Gene Wirchenko

Assembler is definitely a necessary part of teaching computer science. But certainly not as a first language.

FredSaw · 2005-12-01 Reply Admin

Drak:
The fact that more people can use the newer languages (or makes them think the can) obviously makes for more wtf code, but the real WTF is that these people get hired, not that they use VB or C# or whatever.

I started coding as a hobby. I went from Basic to Assembler to C, and then I decided to go to college and make it a career. I studied QBasic as a freshman and Cobol as a sophomore. In junior Data Structures class we coded in C++ while the textbook was still using Pascal (1994). I did a semester of Unix and continued on in C++ in most of my other classes.

After graduation, in my first professional programming job, I discovered that C++ was not in demand; VB3 was what they were using (1995). So I begged a copy and set in to quickly learn VB3 (which had never once been mentioned to us in college). Immediately, VB4 came out and the company switched to it. My C++ fell by the wayside due to disuse as I worked to come up to speed in VB4 in order to please my department supervisor and keep my job.

My first assignment was to convert Cobol mainframe code to VB4 to run on windows workstations. Therein lies a tale, which I will spare you. Suffice to say, it was a major learning experience for me due to the unwillingness of anyone in my department to explain to me how the company worked, what our departmental goals were, how the network was set up, what the Cobol programs were supposed to accomplish, and so forth.

You want WTF code? Cast a newbie out into the sea of steel fabrication corporate bullshit circa 1996, when nobody appreciated the value of IT and we were still the red-haired step-children of the corporate structure. Ask him to justify his salary based on visible output on a daily basis, since nobody in the company's upper management understands that writing code is not the same as having the shop spit out hourly cut/welded/punched/painted pieces of steel to be shipped to a jobsite. They want product, and they want it NOW. That's what they know. So that's what they expect from you.

Drak:
but the real WTF is that these people get hired

It wasn't until I came to my present job, in 2000, that I found a place where I was respected as a full-grown, intelligent, skilled employee. I've been writing code since 1981. I've been through Basic, Assembler, C, QBasic, Cobol, C++, VB3, VB4, VB97, VB6, and finally VB.Net and C#.

I gotcher WTF for you right here. In any other profession--medical, legal, sports, administrative assistant (formerly "secretary"), fry-flipping--what you learn builds and compounds and stays true from year to year, so that as time goes on you become a master at what you do. For example: medical... the names of the parts of the body, and the diseases they can contract, are never going to change. Once you have learned them, you have learned them for life.

In IT, on the other hand, what you learn is obsolete almost as soon as you learn it. In 2000, we all knew VB6. By 2001, VB6 was obsolete and we were all struggling to use .Net in one of it's various forms; mostly VB.Net or C#. Now, we're rolling over to 2006, and what we worked so hard to learn between 2001 and now is obsolete, or almost so. Microsoft has a new set of products, and a new set of certifications to match them. I haven't even reached MCAD status yet, and it's already obsolete.

Don't give me a hard time, Drak. I'm doing the best I can, and the best I can is a pretty damned impressive lot, given the circumstances.

And if all you're doing is coding in Cobol and Fortran, then I'm outrunning your ass all over the place.

masklinn · 2005-12-02 Reply Admin

Anonymous:
suppose that my problem is not so much with whatever particular language a student learns to program in. I mean, you gotta pick one, and yea, you gotta learn the syntax, before you can understand how/what/why to code.

Nope, and that's the problem with C/C++/Java.

Check a basic (no tricks, no obfuscation, your vanilla HW) yet clean (no compilation warning or error) Hello, World! in C, in C++, in Java, in Ruby and in Python, and evaluate the number of concepts to introduce to the students.

Python and Ruby ask for two (strings and statements), C wants at least 4 (including functions), and Java or C++ will require you to introduce soomething like 6 or 7 at least.

My problem is with learning on any IDE that completes statements, loops, functions, subroutines, method calls... etc. for you. How is a student supposed to learn how to program when everything is done automagically for them?

Heh, couldn't agree more with you here, students should never be allowed more than CLI and a basic syntactic coloration editor.

2005-12-02 Reply Admin

I got it, I got it!

He forgot error-handling in case that - looking at fncSetSQL - the string has negative size! See, if the string has a size of < 0, this is an infinite loop! How could yall not have seen this?

2005-12-02 Reply Admin

Hm, my comment was cut. What i wanted to say: if the string has negative size, this is an infitinite loop! How could yall not have seen this?

hank miller · 2005-12-02 Reply Admin

FredSaw:
In IT, on the other hand, what you learn is obsolete almost as soon as you learn it. In 2000, we all knew VB6. By 2001, VB6 was obsolete and we were all struggling to use .Net in one of it's various forms; mostly VB.Net or C#. Now, we're rolling over to 2006, and what we worked so hard to learn between 2001 and now is obsolete, or almost so. Microsoft has a new set of products, and a new set of certifications to match them. I haven't even reached MCAD status yet, and it's already obsolete.

This is false. The syntax changes, but the basics of programming do not. It is more like a doctor going to a country where they speak a different language. He will need some time to learn the language, but there is no need for another 25 years of schooling as well. (Elementary up through college)

Learning a new computer language is much easier than learning a new human language. Within a week you should be comfortable with the syntax, though it can take a couple years to learn the subtile points, a good programmer should be able to good code (though not the best the language is capable of) soon enough.

Gene Wirchenko · 2005-12-02 Reply Admin

ennuija:
Gene Wirchenko:
Anonymous:
Anonymous:
[...] no student should be allowed to use an IDE until at least their second year... ;)

Strike that - make them all learn in assembly language. On computers with 64K of memory. Mwahahahahaha! (kidding, of course... mostly, anyway ;).

I am not though. I have given a fair amount of thought to how people learn to program and how they should.

Assembler is good because it gives a sense of how the machine actually works.

Constraints, such as low memory, help to illustrate trade-offs and why/when you make them. This is part of design.

There may be other ways to do it, but underlying knowledge and the ability to design are very useful and necessary skills for competent software creators.

Assembler is definitely a necessary part of teaching computer science. But certainly not as a first language.

No to your "certainly not".

My first language was assembler. It was a simple assembler, but it was assember. The advantage of assembler is that the student can learn how the machine works. With HLLs, there is so much abstraction that many points do not get clearly made or made at all.

I am not suggesting that someone has to work a lot with assembler, but one-half of a semester ought to about do it. By "it", I mean the building of a foundation of knowledge about how computers work.

I all too often have had to explain very simple concepts to people who think they know programming, that if they had done any assembler to speak of, I would not have to explain at all. When I do, I often have spend a fair bit of time to do it, because the abstractions and user interface get in the way. It takes time to rip that away and get to the nub that it works like this, period, and no, the GUI has nothing to do with it.

Sincerely,

Gene Wirchenko

2005-12-02 Reply Admin

Anonymous:
hmm good code but when i run it i get this?????
...

Was that written by a drunk programmer? The way it weaves back and forth looks like a drunk driver! <G>

ennuija · 2005-12-03 Reply Admin

If you are arguing for teaching assembler first, then I disagree. I do believe that knowing how a computer works at low levels is important, and it is necessary to teach it in computer science curriculum. But starting with it is only going to discourage students. Beginning with a high-level non-compiled language (in my view, Python, Ruby, or Smalltalk are the best choices) would be a good way to quickly get students writing code. These languages make it easy for the students to experiment with what they have learned without having to worry too much about how computers work. This is a good thing.

You might be surprised how many concepts carry over from high-level languages to basic computer architecture; and honestly, assembler is fairly abstracted as well. Do you think students learn much more about how a computer works writing

mov r0, #0
mov r1, #10
@L1:
add r0, r0, r1
subs r1,r1,#1
bne @L1

than

r0 = 0
r1 = 10
while r1 != 0
r0 = r0 + r1
r1 = r1 - 1
end

?

Gene Wirchenko · 2005-12-05 Reply Admin

ennuija:
If you are arguing for teaching assembler first, then I disagree. I do believe that knowing how a computer works at low levels is important, and it is necessary to teach it in computer science curriculum. But starting with it is only going to discourage students.

I think that it is very important to begin with the fundamentals. Treating the computer as a black box does not do this. People exposed only to a high-level view of computers often have very weird ideas about what goes on inside.

It also gets the idea across that programming involves working with very small pieces.

Beginning with a high-level non-compiled language (in my view, Python, Ruby, or Smalltalk are the best choices) would be a good way to quickly get students writing code. These languages make it easy for the students to experiment with what they have learned without having to worry too much about how computers work. This is a good thing.

Learn how to use a computer without worrying about how computers work? Oxymoronic.

I think that the "worrying" (consideration) of consequences is something that must be dealt with in order to get a programmer. With a bit of assembler, it gets the idea across. Then, I would switch to interpreted HLL for the next bit.

You might be surprised how many concepts carry over from high-level languages to basic computer architecture; and honestly, assembler is fairly abstracted as well. Do you think students learn much more about how a computer works writing

mov r0, #0
mov r1, #10
@L1:
add r0, r0, r1
subs r1,r1,#1
bne @L1

than

r0 = 0
r1 = 10
while r1 != 0
r0 = r0 + r1
r1 = r1 - 1
end

?

Potentially.

You have mixed abstraction levels. Will the student really understand the expense of the while statement? On some systems, looping is not as easy as the assembler you have shown and the while would expand into many statements. If the while comparison were to another value, say 10, that would change the assembler code. A beginning student will almost certainly miss this.

I am not suggesting that people do much assembler, but doing some at the beginning gives a better appreciation of how the machine works.

Sincerely,

Gene Wirchenko

ennuija · 2005-12-05 Reply Admin

You're right. It is important to begin with fundamentals. One fundamental we should have begun with is the knowledge level and age of the students we are talking about here. For me, at least, that will make a difference.

People exposed only to a high-level view of computers often have very weird ideas about what goes on inside.

I agree with you. It's funny, I have often found difficulty working with people who have only been exposed to a low-level view of computers. Often they worry too much about the speed and memory footprint of their code, and the readability, utility, extensibility, and correctness are sacrificed. I think you and I both agree that it is important to be a balanced computer scientist in this regard.

Learn how to use a computer without worrying about how computers work? Oxymoronic.

I was a bit unclear. A supreme benefit of high-level interpreted languages is the same for beginners and experts: it is very easy to experiment with and investigate the code as it runs. In this way you can learn many important elements of how computers work -- e.g. sequential execution, control flow, storing and retreiving data, subroutines, simple data structures -- without having to know how it actually works fundamentally.

Will the student really understand the expense of the while statement?

In the Ruby example? Perhaps not at first. But I don't think that's the goal at first. In my opinion, the goal is to get students excited about the possibilities, not bogged down in the details. And as for the asymptotic behavior of the while statement, the assembler version and the Ruby version are identical. You needn't teach assembler to teach optimization.

On some systems, looping is not as easy as the assembler you have shown and the while would expand into many statements.

On all systems the Ruby code will expand into many, many more instructions! But even if we are talking about the compiler-optimized C equivalent, you'd have to be running on a pretty bizarre CPU for that loop to be anything more than five to fifteen instructions. I also am not sure if I follow what your argument is -- optimization on this level is unimportant for the majority of developers these days. If you teach the students profiling and algorithmic and data structure complexity analysis I'm sure it will be plenty.

Anyway, this is an interesting topic, but I think I've threadjacked enough. And those two huge posts above are death to loading this page...!

masklinn · 2005-12-06 Reply Admin

ennuija:
On all systems the Ruby code will expand into many, many more instructions! But even if we are talking about the compiler-optimized C equivalent, you'd have to be running on a pretty bizarre CPU for that loop to be anything more than five to fifteen instructions. I also am not sure if I follow what your argument is -- optimization on this level is unimportant for the majority of developers these days. If you teach the students profiling and algorithmic and data structure complexity analysis I'm sure it will be plenty.

And profiling and allows you to introduce optimization and module rewrite in low level language (since that is fairly easy in Ruby, much more than in ... say... java), introduce low level languages in a timely maneer so that the students see how they may use them and can understand the tradeoffs between low and high level programming.

XoK · 2005-12-13 Reply Admin

b1xml2:
The real WTF is not so much the verbosity of the functions nor the futility of such functions. It's all about SQL Injection Attacks!

"A system is only as secure as your dumbest programmer developing the self-same system."

If you try hard you will see the following ...

"The biggest mistakes are not from beginners but from experts!".

XoK · 2005-12-13 Reply Admin

That remainds me and old story...

When I entered in University at night.. I was working and didn't had much time for school (did dropped school later, due to lack of time).

I had a "chair" Introduction for Programming, to conclude this "chair", there was 2 methods.

Go all days to school and make 7 exams (if average was lower then 10, make the final exam), and a Java project OR make a Java project and go to the final exam.

So, the first time, I have seen the teacher... it was a so much arrogant bastard! When I was talking to him, it was like I was talking to a wall! That atitude was so bad that I selected the second choice... just to not see him!

A conversation with a lot of stupid questions... and tired of him... conversation ended like:

He asked me: "What do you know about Java?"

Me: "Nothing. But it's just one more language. It's all the same."

He: "Are you sure? Only 2 students have tried this, and were studying at day."

Me thinking: "Son of a b..... if I go everyday you will pistin' me off.."

Me: "Of course, I am sure."

So I prefered the second method.

I did it all the hard way...

Had like only 100MB free space and had no space for JBuilder...

Grabbed the MS Java SDK, and did my mini compiler with Homesite, created a button and a batch to execute the code to compile :)

I learned Java and made the project in one weekend, the project was the basics.. make a mini "database".. the usual, list records, view records, save to file, open file, search records.

To the exam I had to practice a lot more...

In the exam, I had to make about 5 short Java programs, all written in paper without computers... I wrote more than 6 pages! Finished the exam with 12, the project was 16, ended with 14 (in scale of 20). And I gave that bastard a lesson!

What helped me, was my background experience, dedication and patience.

For the beginners, what I have to say is that with dedication and patience, everything is possible!

For instances, I learned most of binary operations and some assembler in the ZX Spectrum, and now it's just a nostalgic machine.

Even if the oldest language is completly obsolete, there will be something, that will fit in your future.

Sorry for the long post... it was just my opinion

My 0,02 EUR :)

hank miller:
FredSaw:

In IT, on the other hand, what you learn is obsolete almost as soon as you learn it. In 2000, we all knew VB6. By 2001, VB6 was obsolete and we were all struggling to use .Net in one of it's various forms; mostly VB.Net or C#. Now, we're rolling over to 2006, and what we worked so hard to learn between 2001 and now is obsolete, or almost so. Microsoft has a new set of products, and a new set of certifications to match them. I haven't even reached MCAD status yet, and it's already obsolete.

This is false. The syntax changes, but the basics of programming do not. It is more like a doctor going to a country where they speak a different language. He will need some time to learn the language, but there is no need for another 25 years of schooling as well. (Elementary up through college)

Learning a new computer language is much easier than learning a new human language. Within a week you should be comfortable with the syntax, though it can take a couple years to learn the subtile points, a good programmer should be able to good code (though not the best the language is capable of) soon enough.

Rewarded with Commenting

Leave a comment on “Rewarded with Commenting”