If you want to set and get properties in C# in a type-agnostic way, these are the functions you want to put into a library class somewhere (or, as I did, into the class that uses them):

private object getProperty(object containingObject, string propertyName)
{
    return containingObject.GetType().InvokeMember(propertyName, BindingFlags.GetProperty, null, containingObject, null);
}
 
private void setProperty(object containingObject, string propertyName, object newValue)
{
    containingObject.GetType().InvokeMember(propertyName, BindingFlags.SetProperty, null, containingObject, new object[] { newValue });
}

That’s all I will say on this subject.

Anyway, enough “dear journal”, I really have to quote these few sentences from Thomas Metzinger’s book, Being No One. While they do build on a lot of what he has written up to that point (starting with definitions of “transparency”, said constraints, “representation” and “phenomenal experience”), they’re utterly brilliant on their own as well, I think, and a big stepping stone for tackling the problem known as the hard problem of consciousness.

[...] If all other necessary and sufficient constraints for the emergence of phenomenal experience are satisfied by a given representational system, the addition of a transparent self-model will by necessity lead to the emergence of a phenomenal self. Phenomenal selfhood results from autoepistemic closure in a self-representing system; it is a lack of information. The prereflexive, preattentive experience of being someone results directly from the contents of the currently active self-model being transparent. [...] Under a general principle of ontological parsimony it is not necessary (or rational) to assume the existence of selves, because as theoretical entities they fulfill no indispensable explanatory function. What exists are information-processing systems engaged in the transparent process of phenomenal self-modelling. All that can be explained by the phenomenological notion of a “self” can also be explained using the representationalist notion of a transparent self-model.

Really, just brilliant.

(I do hope that this falls under fair use in the context of scientific research, if the quotation is too expansive please notify me and I will remove it, or narrow it down further, immediately.)

Stack Overflow

If you’re a programmer, you know the problem of solution googlability. It’s particularly prominent in mainstream languages (and one of the things I decried in my What’s Wrong with VBA series, as VBA is particularly bad in that respect); you have a problem, you google for it, unless you’re coding in a good awesome well-designed freak language like Ruby, Python, or Haskell, all you get back is trash and spam.

So, since you’re reading blogs and a programmer (or you’d have stopped reading by now, I guess), you know Joel on Software. Now this guy and his team have done something: They took the Wiki approach of “everybody can edit”, added Digg’s “let’s vote stuff up”, and made the whole thing a generic programming Q&A site.

Behold, and witness, the rise of Stack Overflow.

From his launch post:

Here’s how it’s supposed to work. This is a community project, so I’m being careful to avoid saying this is how it will work… that’s up to the community. But this is roughly what I have in mind.

Every question in Stack Overflow is like the Wikipedia article for some extremely narrow, specific programming question. How do I enlarge a fizzbar without overwriting the user’s snibbit? [...]

Some people propose answers. Others vote on those answers. If you see the right answer, vote it up. If an answer is obviously wrong (or inferior in some way), you vote it down. Very quickly, the best answers bubble to the top. The person who asked the question in the first place also has the ability to designate one answer as the “accepted” answer, but this isn’t required. The accepted answer floats above all the other answers.

Sounds great! It has tags, it’s not restricted to one programming language, it could provide the framework for thousands of programmers collaborating. And the best thing: They plan to “keep it ad-free and open to the public forever”.

You’ll need an OpenID to log in – I got one at myOpenID myself. Too bad it’s not possible to log in without, but whatever – I guess this approach has more promise than the closed one that Microsoft tried to force upon us with that whole Live ID crap, but still shares the same weaknesses (which are, mainly, another party involved and a central point of failure).

Nevertheless, I do think this could be awesome. Let’s see where it goes.

Dim primitiveVector As clsVector
Set primitiveVector = New clsVector
Dim myInt As Integer
myInt = 3
 
primitiveVector.AddItem myInt

There are of course other people who have made such a thing, and there’s the VBA Collection, but none of them quite fit what I wanted. I wanted a Vector that had random access, was able to handle LIFO and FIFO (and thus act as stack and queue), addition and insertion and deletion, could check for item existence, and had dynamic resizing. So I went and coded my own. I did this while working at Promino AG and thus the code is technically theirs, so thanks to Paul Moser for the nod for publishing this under the GNU Lesser General Public License.

You can download both classes (two? more below), together with a tiny trivial testing framework, as Access 2002-2003 .mdb.

This here is the vector class for Variants. It goes into a new class module, I called mine “clsVector”:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

Option Compare Database
Option Explicit
 
' Copyright 2007, 2008 by Promino AG
' Author: Guido Gloor
'
' This program is free software: you can redistribute it and/or modify
' it under the terms of the GNU Lesser General Public License as published by
' the Free Software Foundation, either version 3 of the License, or
' (at your option) any later version.
'
' This program is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' GNU Lesser General Public License for more details.
'
' You should have received a copy of the GNU Lesser General Public License
' along with this program.  If not, see <http://www.gnu.org/licenses/>.

Private itemCount As Integer
Private itemBufferSize As Integer
Private itemBuffer() As Variant
 
Private Sub Class_Initialize()
    itemCount = 0
    itemBufferSize = 100
    NewDimensions
End Sub
 
Private Sub NewDimensions()
    ReDim Preserve itemBuffer(itemBufferSize) As Variant
End Sub
 
Private Sub CheckDimensions()
    If itemCount > itemBufferSize - 2 Then
        itemBufferSize = itemBufferSize * 2
        NewDimensions
    End If
End Sub
 
Public Sub ShrinkDimensions()
    itemCount = itemBufferSize + 10
    NewDimensions
End Sub
 
Public Function GetSize() As Integer
    GetSize = itemCount
End Function
 
Public Sub AddItem(item As Variant)
    CheckDimensions
    itemBuffer(itemCount) = item
    itemCount = itemCount + 1
End Sub
 
Public Function GetItem(index As Integer) As Variant
    GetItem = itemBuffer(index)
End Function
 
Public Function PopItem() As Variant
    PopItem = itemBuffer(itemCount - 1)
    DeleteItem itemCount - 1
End Function
 
Public Function GetNextQueueItem() As Variant
    GetNextQueueItem = itemBuffer(0)
    DeleteItem 0
End Function
 
Public Function ContainsItem(item As Variant) As Boolean
    Dim i As Integer
    ContainsItem = False
 
    For i = 0 To itemCount - 1
        If itemBuffer(i) = item Then ContainsItem = True
    Next i
End Function
 
Public Sub InsertItem(index As Integer, item As Variant)
    Dim i As Integer
 
    CheckDimensions
    For i = itemCount - 1 To index Step -1
        itemBuffer(i + 1) = itemBuffer(i)
    Next i
    itemBuffer(index) = item
    itemCount = itemCount + 1
End Sub
 
Public Sub DeleteItem(index As Integer)
    Dim i As Integer
 
    For i = index + 1 To itemCount - 1
        itemBuffer(i - 1) = itemBuffer(i)
    Next i
    itemCount = itemCount - 1
End Sub
 
Public Function IsEmpty() As Boolean
    IsEmpty = itemCount <= 0
End Function

Now, it would be nice if we would be done. But, we’re not done yet, obviously, after all there’s plenty more code below this break. The reason for that is simple: In VBA, a Variant is not an Object, and an Object is not a Variant, consequently functions that take Objects don’t take Variants and vice versa (although you can technically store an Object in a Variant, this will lead to problems). Objects also happen to have “Set” mandatory in places where it isn’t allowed for Variants.

What this means is that there is no way to have the same Vector class for both your custom ADTs and the primitive data types. So basically, we have another class that has exactly the same functions and exactly the same algorithms, but takes Objects instead of Variants. I called mine “clsObjectVector”. Here is the source for the class module:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

Option Compare Database
Option Explicit
 
' Copyright 2007, 2008 by Promino AG
' Author: Guido Gloor
'
' This program is free software: you can redistribute it and/or modify
' it under the terms of the GNU Lesser General Public License as published by
' the Free Software Foundation, either version 3 of the License, or
' (at your option) any later version.
'
' This program is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' GNU Lesser General Public License for more details.
'
' You should have received a copy of the GNU Lesser General Public License
' along with this program.  If not, see <http://www.gnu.org/licenses/>.

Private itemCount As Integer
Private itemBufferSize As Integer
Private itemBuffer() As Object
 
Private Sub Class_Initialize()
    itemCount = 0
    itemBufferSize = 100
    NewDimensions
End Sub
 
Private Sub NewDimensions()
    ReDim Preserve itemBuffer(itemBufferSize) As Object
End Sub
 
Private Sub CheckDimensions()
    If itemCount > itemBufferSize - 2 Then
        itemBufferSize = itemBufferSize * 2
        NewDimensions
    End If
End Sub
 
Public Sub ShrinkDimensions()
    itemCount = itemBufferSize + 10
    NewDimensions
End Sub
 
Public Function GetSize() As Integer
    GetSize = itemCount
End Function
 
Public Sub AddItem(item As Object)
    CheckDimensions
    Set itemBuffer(itemCount) = item
    itemCount = itemCount + 1
End Sub
 
Public Function GetItem(index As Integer) As Object
    Set GetItem = itemBuffer(index)
End Function
 
Public Function PopItem() As Object
    Set PopItem = itemBuffer(itemCount - 1)
    DeleteItem itemCount - 1
End Function
 
Public Function GetNextQueueItem() As Object
    Set GetNextQueueItem = itemBuffer(0)
    DeleteItem 0
End Function
 
Public Function ContainsItem(item As Object) As Boolean
    ' The used ADTs need to have an Equals function for this to work
    Dim i As Integer
    ContainsItem = False
 
    For i = 0 To itemCount - 1
        If itemBuffer(i).Equals(item) Then ContainsItem = True
    Next i
End Function
 
Public Sub InsertItem(index As Integer, item As Object)
    Dim i As Integer
 
    CheckDimensions
    For i = itemCount - 1 To index Step -1
        Set itemBuffer(i + 1) = itemBuffer(i)
    Next i
    Set itemBuffer(index) = item
    itemCount = itemCount + 1
End Sub
 
Public Sub DeleteItem(index As Integer)
    Dim i As Integer
 
    For i = index + 1 To itemCount - 1
        Set itemBuffer(i - 1) = itemBuffer(i)
    Next i
    itemCount = itemCount - 1
End Sub
 
Public Function IsEmpty() As Boolean
    IsEmpty = itemCount <= 0
End Function

This is it, have fun As much as you can have if you’re forced to work with VBA, that is.

Oh, and if you can use it – comments are appreciated