For nearly two years, Hank T. tried his best to avoid the CEE system. He even made an effort to not know what CEE stood for (though he was pretty sure it was Customer something Engagement). But alas, the inevitable happened and he was finally tasked with fixing a bug in CEE.

Years ago, the CEE system was created by a developer who lived by The One Rule: there are no rules, not even The One Rule. And not surprisingly, his code showed for it. To investigate the bug he was assigned to fix -- Customer Versions aren't sorting properly -- Hank dove in to CustomerClass.vb, one of the thousands of VisualBasic.NET code files that made up the application.

Public Function Is_Customer_Version(ByVal Customer_Version_p As CV) As Boolean
    begin()
    Return Customer_Version = Customer_Version_p
End Function 'Is_Customer_Version


Public ReadOnly Property Customer_Version() As CV
    Get
        begin()
        Return My_Customer_Version.Customer_Version
    End Get
End Property 'Customer_Version

'-- OBSOLETE, use (Is_)Customer_Version
Public ReadOnly Property CustomerVersion() As CV 
    Get
        begin()
        Return Customer_Version
    End Get
End Property 'CustomerVersion

It didn't seem all that bad. The call to begin(), however, piqued his curiosity. Hank opened up the file that defined the method, syntax.vb:

Public Sub block()
End Sub

Public Sub begin()
End Sub

Public Sub end_block()
End Sub

Public Sub none()
End Sub

'---------------------------------------------------------------------
'---------------------------------------------------------------------
'-- Abort program
'---------------------------------------------------------------------
'---------------------------------------------------------------------
Public Sub exit_main()
    begin()
    End
End Sub

Public Function false_(ByVal ParameterName As String) As Boolean
    begin()
    Return False
End Function

Public Function true_(ByVal ParameterName As String) As Boolean
    begin()
    Return True
End Function

Public Function Boolean_Val(ByVal n As Integer) As Boolean
    begin()
    Return n <> 0
End Function

Public Function Array_Length(ByVal Length As Integer) As Integer
    begin()
    Return Length - 1
End Function 'Array_Length

Public Function abs(ByVal value As Long) As Long
    begin()
    Return Math.Abs(value)
End Function

Public Function abs(ByVal value As Integer) As Integer
    begin()
    Return Math.Abs(value)
End Function

Public Function abs(ByVal value As Single) As Single
    begin()
    Return Math.Abs(value)
End Function

Public Function abs(ByVal value As Double) As Double
    begin()
    Return Math.Abs(value)
End Function

Public Function abs(ByVal value As Decimal) As Decimal
    begin()
    Return Math.Abs(value)
End Function

Public Function remainder(ByVal a As Long, ByVal b As Long) As Long
    begin()
    Return a Mod b
End Function

Public Function remainder(ByVal a As Integer, ByVal b As Integer) As Integer
    begin()
    Return a Mod b
End Function

Public Function remainder(ByVal a As Single, ByVal b As Single) As Single
    begin()
    Return a Mod b
End Function

The insanity continued, redefining much of Math and the basic arithmetic operators. Further down in the file, Hank spotted the in_() set of methods...

Public Function in_(ByVal v As Long, ByVal p1 As Long) As Boolean
    begin()
    Return v = p1
End Function 'in_(1)

Public Function in_(ByVal v As Long, ByVal p1 As Long, ByVal p2 As Long) As Boolean
    begin()
    Return v = p1 OrElse v = p2
End Function 'in_(2)

Public Function in_(ByVal v As Long, ByVal p1 As Long, ByVal p2 As Long, _
                    ByVal p3 As Long) As Boolean
    begin()
    Return v = p1 OrElse v = p2 OrElse v = p3
End Function 'in_(3)

Public Function in_(ByVal v As Long, ByVal p1 As Long, ByVal p2 As Long, _
                    ByVal p3 As Long, ByVal p4 As Long) As Boolean
    begin()
    Return v = p1 OrElse v = p2 OrElse v = p3 OrElse v = p4
End Function 'in_(4)


-- snip --

Public Function in_(ByVal v As Long, ByVal p1 As Long, ByVal p2 As Long, _
                    ByVal p3 As Long, ByVal p4 As Long, ByVal p5 As Long, _ 
                    ...
                    ByVal p18 As Long, ByVal p19 As Long, ByVal p20 As Long _
                    ) As Boolean
    begin()
    Return v = p1 OrElse v = p2 OrElse v = p3 ... OrElse v = p20
End Function 'in_(20)

More accurately, they were the Long set of _in() methods. There were twenty overloads each for String, Double, Char, and Decimal.

Although this was just the beginning of syntax.vb, Hank decided it best for his sanity to just fix the bug. Though he suspected that the ECC system was yet another tentacle of the great Codethulhu, he knew that, by the time he'd verify that, he would already be insane.