:

## Anti-pattern of the Week

Maple

I recently ran into an interesting twist on the infamous Maple anti-pattern:

`# A very garbagey way to build a listl := [];for i from 1 to 10000 by 100 do    l := [op(l), isqrt(abs(floor((5000-i)/2)))];end do;`

A lot of users fall prey to this method of building a list rather than using :

`# generate a list without extraneous garbagel := [seq(isqrt(abs(floor((5000-i)/2))),i=1..10000,100)];`

So, now the twist. The same problem can also crop up in taking a list apart.

`# A very garbagey way to find the min in a listwhile nops(l) > 1 do    if l[1] > l[2] then	l := subsop(1=NULL, l);    else        l := subsop(2=NULL, l);    end if;end do;op(l);`

Upon first glance this code is pretty clever, but in fact, it has exactly all the bad features of constructing a list in a loop, namely, for a list of length N, the loop uses memory O(N^2). In this case, the boring method is much better:

`# find the min without extra garbagem := l[1];for i in l do    if m > i then	m := i;    end if;end do;m;`

Of course, you should really use min, but in this case the user was implementing with a custom comparator like the two argument version of sort.

These code snippets are also good arguments for programming in a font that allows one to distinguish between 1, l, and i (and I and |) at glance. (Bad even in <tt> for my browser font: )

﻿