Sources (German) claim that other multiplications which should result in 65,535 are also borked.  The borgs of One Microsoft Way claim the error also happens with 65,536, affects most, but not all operations (i.e. it’s not a multiplication specific error), and that some multiplications do work. They go on to claim that the fault is only in displaying, not in the calculation itself.

Unfortunately, others show that rounding said “correct” value in the cell still gives the wrong answer, yet others claim that rounding still produces a borked number for the disyplaying routine.  Enough people copy and paste the data displayed, so this is not a “display only, harmless” bug.

So what can one say?

1. MS’s spreadsheet is not a tool to base your company on: these bugs can kill you.
2. Even if it was bugfree, it’d not be something to base your company on:
• spreadsheets are a programming language.
• Non-programmers create spreadsheets, programming while not even understanding what they are doing.  Like the drunk believing zie is perfectly capable to handle a car, non-programmers overestimate their skill and usually do not do any testing or reviewing.
• The result?  Spreadsheets are ripe with bugs.  They cause people to be wrong about sums like $1.2 billion ($1.2*10^9), which is not exactly pocket money for most companies.

So, basically, if you use a spreadsheet, you are not going to excel.  You are going to underwhelm your boss, once he really has the numbers checked.  As this is the case, it does not really matter that the calculation skill of MS software is, well, less than stellar, so maybe we can call it SubStellar now, a far more matching name.

Last, but not least: it’s interesting to know MS is still having problems when it comes to more than 16 bit.

Workaround: Use the SubStellar version which passed it “best before” date in 2003, i.e. 4 years ago.  If the bit rot lets you.  If not, you are not off worse in any way.

Update: MS managed to fix what they claim was only a display error now.  How … nice.

You know, I’ve been around since before there was spam, unless it was Spam(R) from Hormel.  I remember Canter & Sigel.  I still wish the Roman method of feeding some to lions were around, it would be just right for repeat, unrepentant spammers.  Should get good ratings on TV, as well, helping to defray the costs they produce.   And it would be healthy, familiy entertainment.

So I get a mail from WordPress — someone left a comment for this page.  Spammedy spam spam spam spam spam.

Anyone out there prepared to lobby declaring strangling spammers as legal, under a “he needed killin’” clause?

Frequently Asked Questions’s
an apostrophe does not mean BE CAREFUL, here comes an “s”!

1. How do I runterlade?
   You are able, while you runterladebutton on the assignment, click on runterlade thank you to paging. To return to the assignment thank you to paging use the earningtalealliance to make accessible your assignmentdetails. Click-ici-your earningtale make accessible.
2. Where do I runterlade company share?
   You can download the company share everywhere, so you be fond of overhaul straight line whether the position, in which you saved it, and to remember of the name of the company share. If you should enact to runterlade to writing table, he is easier, therewith you fit the commodity, onetime, you have conducted the download.
3. What happens while I download?
   One time the runterlad incipiencies, you see a closet with a state pole overhead to backfire, and a poundage which climbs to 100%.
4. What happens after I download?
   After a download enforced is, you must go to station, so that you the company share saved and duplicate next to the new religious icon click to start the installation. If you do recive a endorsenemtemail which is not from us, please check your Spam(R), mainpart or your rummage postal booklet. If you find the email there, supervise your International Ship and Port Facility Security or your separate SoftwareSpamBlocker or -filter of our email.
   Annotation: Some backfireoverheadblocker and fire partition programs as well as power of procuration operators, can prevent communication with our operator. If you use all these types of exercise, you must be able to barricade them.

Maybe I speak with a perfect accent without the slightest trace of Engrisch in it … but does that not parse as:

1. advocate for ${company}’s customer base (a perfectly sane requirement) and
2. BE ${company}’s customer base?

Somehow I cannot help feeling that is not what they meant, but what do they mean?

• The basic idea that people need outside motivation is wrong.
  • Management consistently overestimates the effects of their efforts to “motivate” their employees.
  • The self-identification of the workers with their work is consistently underestimated.
  • Motivation by itself is worthless — results are wanted and needed, they are, after all, what is being sold.
• Results are not merely archived by motivation.
  • Employees also need knowledge and skills, and ways to apply the same.
  • If you cut down the possibilities for employees to apply their skills and knowledge, motivation drops.
  • There is no way for management to “press some buttons and say: ‘be more motivated now’”. That does not work and does not counter the now-restricted possibilities of the employee.
• Bonuses and company excursions do not generate motivation.
  • Company excursions do build group spirit and are important, but do not cause motivation as such for the work.
  • Certificates and laurels (“employee of the quarter”) can actually demotivate — those who do not get them.
  • Amenities like laptops, blackberries or company cars demotivate: By continually rewarding people, you replace the work to be done with the reward. This destroys all self-motivation in due time — you no longer do the work because you like it, you merely do it for these rewards. Just what you need.
  • The same is true for bonus payments based on metrics of the individual. This turns employees from cooperating to competing against each other, causing them to put their own aim, reaching for the bonus, before the companies’ aim, producing profit. At worst, they even manipulate the metrics.
• These kinds of bonuses destroy cooperation and collaboration.
  • (this is not a point in the article) This strategy works well when conquering nations or controlling prisons. Divide et Impera. Divide and rule. Sow mistrust (“he gets so many privileges — is he a snitch for the prison wards?”, “Is she telling the management things? She’s got a large bonus and didn’t do more than we did!”) and you can play out the inmates against each other. There won’t be cooperation, hence there won’t be an uprising against you.
  • (this is not a point in the article) This ultimately leads to workplace bullying, costing uncounted billions every year. Including withheld information, slow reactions to needs, work to rule
• Global bonuses based on the results of the company are different, as they do not hinder cooperation.
• Is what you are doing something you like spending time on? And is that wanted in the company, in the department? If yes, there should be no motivational problem; if no, you want to find a new job.

It’s very, very hard to un-learn concise programming and go back to medieval programming times. And converting existing code is even harder.

So says Re^2: Is Perl a good career move?, and guess what, it’s right. I am running straight against The Blub Paradox (ca. in the middle of the page) — people don’t understand what having Perl’s “local” variables give you.

You can, in PHP, create lambda functions, which can be sorta-lika anonymous functions, except they are not anonymous, but named /\{NULL}lambda_[0-9+]/. And create_function() has a stupid and hard-to-work-with syntax. And you cannot reliably tell if a hash entry is a string or what in Perl would be called a code ref. Observe:

Perl:
$i = sub { return 22 + $::increase};
local $::increase = 1;
$ans = ref($i) eq "CODE" ? &$i() : $i; # works also for $i = 23;

PHP:
$i = create_function('$c', 'return (22 + $c);');
$increase = 1;
$ans = strcmp(substr($i, 0, 8), "^@lambda_") == 0 ? $i($increase) : $i;

Guess which one is more compact, guess which one tells you more what is meant to happen …
Oh, the strcmp can go wrong! It depends on in-band signalling (namely the name, and what stops me creating a \{NULL}lambda_42 name?) and is thus unreliable.

It is possible to use both Perl and PHP, but it is not easy. Once your mind thinks in maps, greps, arrays, lexicals, closures, namespaces and short circuiting operators, PHP is a major pain in the ass. You can still get the job done, but it hurts mentally and IMO, not much is worth that. (Note: do not read that as “that is not worth much”)

And

Indeed, once your mind additionally thinks in first-class classes, restartable conditions, unwind-protect (or CALL/CC for the Schemers), bignums, arbitrary-precision arithmetic and is used to building your own abstractions (without jumping through hoops) and incrementally updating/changing programs (including the compiler/runtime) while they run, almost all languages become a major pain in the ass.

(Yes, that’d be Lisp and Scheme and friends.)

In closing: PHP is a great language for incompetent programmers writing trivial or unmaintainable small programs, which work most of the time. Mostly.

PHP’s simplicity makes it a good language for inexperienced programmers, such as those moving from a pure page-design rôle to a site development one.

For more experienced developers, though, the language’s simplicity rapidly turns into complexity, slowing down the development process. These developers are the ones who have the skills needed to build large and/or complex websites; using PHP for such sites therefore tends to be a net loss. This tendency is reinforced by PHP’s lack of the linguistic features needed to promote working on large software projects. If your project is at all large or complex, it may be better to look elsewhere when choosing an implementation language.

See here.

function FUNCTION ($var, $var2, $var3 = false, $var4 = 15) {}
versus
sub FUNCTION {
my ($var, $var2, $var3, $var4) = @_;
$var4 ||= 15; # not the exact equivalent!
}

BEGIN { my $v = 10;
sub may_try_again { return unless $v-- > 0; }
}

In PHP there are global variables (and superglobals), lexically scoped variables (simply invoke a variable in a function), static variables, packagewide variables:

class PACKAGE {
private $variable1;
public $variable2;
}

(where $variable2 can be accessed from an instance of PACKAGE as $a = new PACKAGE; $a->variable2).

However, what is missing is (in Perl): local $::variable;.
For those who have no idea what that does: It’s scoped, but not _just_ lexically — it is also visible within all subroutines. After a local variable goes out of scope, any previous (local or global) variable becomes visible again.

That means local $::variable is a good way to pass information to sub-subroutines, or temporary change some default, including Perl defaults. A common idiom is { local $/ = undef; $slurp = <FILE>; }, which switches Perl into slurp mode (sucking in the whole file, by default it’s by paragraph), but also resets $/ automagically on leaving the scope.

So in PHP you have to use class variables and hope you never cross class/inheritance borders or pass on the whole set of data to the next subroutine. Gah. (Yes, I know some people don’t understand why it might be needful.)

Why must I type
list ($var1, $var2, $var3) = array ("one", "two", "three");
instead of
($var1, $var2, $var3) = ("one", "two", "three");
or even
($var1, $var2, $var3) = qw(one two three);
? All the syntactic arsenic (it’s not sugar any more) is hiding the real content.

Why can’t I use
$f = function ($x) { return $x + 2; }
but must use
$f = create_function ('$x', 'return $x + 2;');
, a completely different syntax, and one that needs lots of escaping?  Grumble.  So much for consistency.

Assume you have a bunch of user generated functions, references of them stored in an array. (Yes, eval is rarely the answer, but sometimes it is.) Assume you have most of them just returning a fixed value. You wouldn’t want them to be functions, a scalar (string, number, whatever) is sufficient.

In Perl, I can say
my $ans = (ref($f) and ref($f) eq "CODE") ? &$f : $f;
and get either the value of the scalar $f or the return value of the function $f.

In PHP, there is no good way to find out if $f is a string or a (pointer to a) function. is_callable() is a nice try …

function crap () {}
$f = "crap";
print 'is_callable($f): ' . is_callable($f) . "\n";
returns is_callable($f): 1. I am sooo thrilled.

In Perl it’s easy:
sub crap {};
$f = "crap";
$g = sub { return "crap"; };
print "f: ", ref($f), "\n";
print "g: ", ref($g), "\n";
returns
f:
g: CODE
(OK, you’d get a warning with -w, since ref($f) is undefined, but the difference is clear.)

At least with something like
create_function('$x', 'return "27";');
I get names starting with “^@lambda_“, which at least allows some heuristic.

For better or worse, I can now sic the admins on working that out with exim on my machine. Makes me almost glad I no longer have any root access on my machine. On the other hand, it’ll probably take them weeks to do that. Again. I love having to tell them to apply security fixes and getting threats they’ll force me to use Windows.

PS: the official workaround is “use OWA” (Outlook Web Access).  Combining the worst of both worlds, being a pain in the posterior to use, slow, incapable of correct threading … I need that even worse than I need all my teeth kicked out.

And yes, it used to work.

Of course, that is very very dangerous, so dangerous that  it cannot be allowed to happen without close supervision.  You touch that table, you better be prepared to defend your choice in front of the Spanish inquisition.  No, they won’t change that.  After all, that may cause some SOXocrat to look closer, or they having to explain themselves.

Yet another win of SOX over human reasoning.