Home office

Mein Arbeitsplatz

Ein Artikel über Heimarbeit muss mit einem Bild des eigenen Arbeitsplatzes beginnen. Hier also, ein Foto meines Arbeitsplatzes in Wilhelmshorst.

IMG_3455

Ehrlich gesagt ähnelt mein Arbeitsplatz zuhause ziemlich meinem Arbeitsplatz im Büro.

Was bedeutet für mich Arbeiten von zuhause

Heimarbeit, bedeutet für mich, die Möglichkeit an etwas Bestimmten konzentriert, ohne große Ablenkung arbeiten zu können. Ganz einfach dadurch, dass die Entfernung es schlichtweg nicht möglich macht, den üblichen Talk auf dem Gang zu führen. Diese Summe, der kleinen Ablenkungen fällt weg, was für mich manchmal eine große Erleichterung ist.

Dennoch achte ich in der Heimarbeit immer darauf für meine Kollegen erreichbar zu sein. Ich lese meine Emails und habe, neuerdings, Microsoft Lync gegen meinen Standard IM getauscht. Beide Kommunikationsmittel geben mir die Möglichkeit, meinen Status auf beschäftigt zu setzen. Ein klares Signal, jetzt nicht gestört werden zu wollen.

Erreichbar bin ich aus zwei Gründen. Erstens, bin ich gerne hilfsbereit. Und zweitens, signalisiere ich damit, dass ich Teil eines Teams bin, auch wenn ich gerade nicht Vorort bin. Ich finde, man darf den zweiten Punkt nicht unterschätzen. Gerade unser Beruf gibt uns die Möglichkeit zwar räumlich getrennt, trotzdem aber thematisch nahe beisammen zu sein.

Wichtig ist für mich allerdings, den Mitgliedern in meinem Team zu zeigen, dass ich bei ihnen bin. Telefonisch oder per IM erreichbar zu sein ist eine Sache. Viel wichtiger ist allerdings, andere an der eigenen Arbeit teilhaben zu lassen. Dies geht über verschiedene Wege. Das kann eine E-Mail am Vortag sein, in der man kurz den Kollegen erklärt, was man vorhat zu erreichen. Das kann aber auch ein spannender Wiki-Eintrag sein, oder ein kurzer Vortrag in einem Meeting.

Let’s geek out

Das Thema Erreichbarkeit im Home Office geht natürlich nicht ohne ein paar Details zu meiner Ausstattung.

Ich benutze ein Lenovo w520 Laptop, das ich mit zwei externen Monitoren betreibe. Eine nahezu identische Aufteilung habe ich an meinem Arbeitsplatz im Büro, was nicht ganz unwichtig ist, wie ich finde. (Mögen die, die morgens gern am Frühstückstisch mit ihren Laptops einfach sitzenbleiben und arbeiten, das für spießig halten).

Daran angeschlossen habe ich eine, wirklich gute, Microsoft LifeCam Studio WebCam. Und, da Heimarbeit ohne ein gutes Headset unmöglich ist, habe ich das schnurlose Logiteach H800.

Unser Haus ist mit 30 MBit/s down- 3 MBit/s upstream per VDSL an das Internet angeschlossen. Das Arbeiten per RDP auf anderen Rechner im Büro, bei unserem Provider oder auf irgendwelchen Rechnern dieser Welt, ist damit kein Problem. Im Gegenteil, manchmal ist es besser als im Büro Winking smile

Have fun working remote!

Advertisements

A little round trip using TDD (Part 2)

In the first part of this series we saw how to create tests and used those tests while implementing production code. We also saw that writing tests mustn’t be an inefficient approach at all.

Next, I would like to move along and use the code in the test methods as a basis for XML comment based documentation of the production code.

XML Documentation

VB.Net allows code documentation in XML on several places. You can add XML comments to classes, methods, properties and more. Here’s a snippet from a WCF contract, showing the XML documentation comments on to of the method signature.

image

You can see, that I just copied the test code from the method into the code XML element. BTW, I set the language in the lang attribute to VB.NET, which later is recognized by the help file viewer and syntax highlighting for VB.NET is supported.

Read more about Documenting your Code with XML on MSDN here.
And the recommended XML Tags for Documentation Comments here.

Sandcastle

As mention earlier I’m using the Sandcastle documentation engine to compile help files based on the XML documentation in the project. Here’s a screenshot of the Sandcastle Help File Builder UI.

image

Sandcastle has quite a bunch of settings, but it comes with a very handy UI application. And if all settings are done, you generally don’t have to touch the project file again.

I usually add a msbuild task to the post-build event and run the compilation of the help project every time I do a Release build.

Or, you simply call msbuild from the command line to compile the Sandcastle project file, like

C:\Windows\Microsoft.NET\Framework\v4.0.30319\MSBuild.exe /p:Configuration=Release <documentaion-project-file>.shfbproj

I recommend to compile the help file only if you do a Release build, because it can take some minutes, depending on the amount of classes containing in the assemblies you like to get documented.

If the documentation is compiled you get a typical Windows compiled help file *.chm or a MSDN documentation like website.

Read more about Sandcastle – Documentation Compiler for Managed Classes here.

Have fun!

VB.Net secretly in love with XML

I know this is an old topic, but it always fascinates me. Actually, I don’t care what language in the .Net universe you use. If it’s C# or VB.Net, it doesn’t matter in the end, both languages are only two different dialects and compiled to the same IL code anyway. But, there is one thing that I really like in VB.NET, and that is the brilliant integration of XML. This goes out to all C# coders, have a look how VB.NET is capable of dealing with inline XML, thanks to T4 templates, compiled in the background.

Here’s a simple example, how a XML document is created. The functions only purpose is to create an XML element type, fills that by adding some child elements and returns the element.

    Public Function GetReport() As XElement

        Dim xml = <DSMIBenchmarkReport>
                      <Created><%= Now.ToString %></Created>
                      <StressTestMode><%= StresstestMode.ToString %></StressTestMode>
                      <Threads><%= My.Settings.ThreadCount %></Threads>
                      <IterationsPerThread><%= My.Settings.IterationsPerThread %></IterationsPerThread>
                      <Started><%= TRs.Started %></Started>
                      <Finished><%= TRs.Finished %></Finished>
                    </DSMIBenchmarkReport>

        Return xml
    End Function

If you are familiar with ASP.NET this might ring a bell. It’s easy to add elements and assigning values to the elements by putting types and properties in <%= and %> is Childs play. The VB compiler can then apply a T4 template to this and generate the XML at compile time.

You can even iterate through collections, like shown in the following example.

Public Function GetReport() As XElement

        Dim xml = <DSMIBenchmarkReport>
                      <Created><%= Now.ToString %></Created>
                      <StressTestMode><%= StresstestMode.ToString %></StressTestMode>
                      <Threads><%= My.Settings.ThreadCount %></Threads>
                      <IterationsPerThread><%= My.Settings.IterationsPerThread %></IterationsPerThread>
                      <Started><%= TRs.Started %></Started>
                      <Finished><%= TRs.Finished %></Finished>
                      <Details>
                          <%= From ex In TRs Where Not String.IsNullOrEmpty(ex.ExceptionMessage) Select (New XElement("Exception", New XAttribute("Message", ex.ExceptionMessage))) %>
                      </Details>
                  </DSMIBenchmarkReport>

        Return xml
    End Function

Here we iterate through a collection of possible exceptions but add the element only to the Details parent element if the exception text is not empty.

In case you have some extra logic to decide whether you add an element or not, you could move that code into an extra function like shown in the next example.

Public Function GetReport() As XElement

        Dim xml = <DSMIBenchmarkReport>
                      <%= GetRandomMode() %>
                      <Created><%= Now.ToString %></Created>
                      <StressTestMode><%= StresstestMode.ToString %></StressTestMode>
                      <Threads><%= My.Settings.ThreadCount %></Threads>
                      <IterationsPerThread><%= My.Settings.IterationsPerThread %></IterationsPerThread>
                      <Started><%= TRs.Started %></Started>
                      <Finished><%= TRs.Finished %></Finished>
                      <Details>
                          <%= From ex In TRs Where Not String.IsNullOrEmpty(ex.ExceptionMessage) Select (New XElement("Exception", New XAttribute("Message", ex.ExceptionMessage))) %>
                      </Details>
                  </DSMIBenchmarkReport>

        Return xml
    End Function

    Private Function GetRandomMode() As XElement
        Dim randomMode As XElement = New XElement("RandomMode")

        If My.Settings.CounterStartValue > 0 Then
            randomMode.Add(New XAttribute("Mode", "Counter"), New XAttribute("StartValue", My.Settings.CounterStartValue))
        Else
            randomMode.Add(New XAttribute("Mode", "Characters"), New XAttribute("Characters", My.Settings.RandomCharacters))
        End If

        Return randomMode
    End Function

Here we are adding an extra element called RandomMode, but how this new element should behave is defined in the function we call, the GetRandomMode method. Because the function is returning an XElement type, we can simply do the call inside the <%= and %> in the XML from above.

Have fun!