Git may be the source versioning control of choice for most developers today, but centralized source control systems like TFS and Subversion are still used by many older repositories. That is the case in my company, where we have 15 year-old source code in TFS while newer repositories are in Azure DevOps (Git).

I was doing a repository clean-up and wanted to remove NuGet packages that were downloaded and checked-in. This was common practice back in the day of unreliable/slow Internet but is generally frowned upon these days because it bloats up the repository over time. Old packages are not automatically deleted by TFS when they’re upgraded so they stay in the repo. Have you met many devs who lovingly curate their packages or node_modules folder by hand?

Sorry, digression over! Anyway, when I tried to check in my Delete operation it failed with the dreaded error message:

Unable to perform operation on $/repo/Service/Packages. The item $/repo/Service/Packages/Utility 1.09/utility.dll is locked in workspace DEMO206;Admin - Carol Danvers

There are different solutions to this issue depending on your specific situation:

1. The user is still in the organisation and have their local environment: This is the easiest scenario to be in. Just ask the user to unlock the folder in Source Control Explorer.
2. The user is no longer in the organisation but their local environment still exists (i.e. their work laptop has not been wiped): You can ask IT to re-activate their account, log in as them, and unlock the folder. But it’s easier to ask the TFS administrator to follow my steps below.
3. The user is no longer around and their local environment no longer exists (i.e. their work laptop has been wiped): My suggestion is to delete their entire workspace, which will also remove all locks that they owned. Ask the TFS administrator to follow my steps below.

Delete TFS workspace of ex-employee

Pre-requisites

1. TFS administrator permissions
2. Windows environment with Visual Studio installed, in order to get TF.exe command line tools. A recent version of Visual Studio like 2017 or 2019 will do.

Get list of TFS workspaces on the server

First, we want to get the list of TFS workspaces on the server so we have the exact names that we will need for the next step.

1. Launch Developer Command Line or Developer PowerShell for Visual Studio. This makes sure TF.exe is in the PATH.
2. Modify and run the following command, which outputs details of all workspaces registered on the TFS server into an XML file.

   TF workspaces /collection:http://tfsvc:8080/tfs/DemoTeamProject /Owner:* /Computer:* /format:XML > c:\temp\workspaces.xml
   

This will result in an output like this in workspaces.xml:

  <Workspace computer="DEMO206" islocal="true" name="DEMO206" ownerdisp="Admin - Carol Danvers" 
  ownerid="S-1-5-22-2456812397-2423433832-269712057-11353" ownertype="System.Security.Principal.WindowsIdentity" 
  owner="4d74d864-53dc-4d11-8095-7ec8bb9121f6" owneruniq="4d74d864-53dc-4d11-8095-7ec8bb9121f6">
    <Comment />
    <Folders>
      <WorkingFolder local="C:\src\DemoProject" item="$/" />
    </Folders>
    <LastAccessDate>2019-03-28T08:42:13.39+13:00</LastAccessDate>
    <OwnerAliases>
      <string>DEMODOMAIN\a-cdanvers</string>
      <string>a-cdanvers</string>
      <string>Admin - Carol Danvers</string>
    </OwnerAliases>
  </Workspace>

Delete workspace

Next, we will delete the user workspace with a simple command, but we may need to try various permutations of the username.

1. Launch Developer Command Line or Developer PowerShell again if you closed it.
2. Determine workspace name possibilities, which is usually a concatenation of the name element and one of the user identifiers. Referring to the sample XML above, the full workspace name could be one of the following:
   1. DEMO206;Admin - Carol Danvers name;ownerdisp
   2. DEMO206;S-1-5-22-2456812397-2423433832-269712057-11353 name;ownerid
   3. DEMO206;DEMODOMAIN\a-cdanvers name;OwnerAliases
   4. DEMO206;a-cdanvers name;OwnerAliases
3. Modify and run the command below, trying out one workspace name combination at a time.

   tf workspace /server:http://tfsvc:8080/tfs/DemoTeamProject /delete " DEMO206;a- cdanvers"
   

If it’s the wrong combination you will see error messages like this:

TF14061: The workspace DEMO206;S-1-5-22-2456812397-2423433832-269712057-11353 does not exist.
TF14061: The workspace DEMO206;Admin - Carol Danvers does not exist.

If it’s the right combination you will be prompted to confirm the deletion (and please do double-check!)

Success!

References

I figured out the different workspace name combinations on my own. If your situation is unique you can refer to the following references or ask a question on StackOverflow.

• tf workspaces command (Microsoft Docs)
• tf workspace command (Microsoft Docs)
• Cleanup workspaces

I am in the middle of changing jobs and had roughly two weeks of ‘me’ time. I was planning to take a holiday but the Covid-19 pandemic scuppered any thoughts of that nature. Therefore, I decided to make this a time of learning instead. I called it my “12 Days of Learning” - one new tech each workday. My goal was not to become an expert on each topic by the end of 8 hours, but to know enough to hold a conversation about it. This means I:

• Understand the rationale behind this technology
• Know the right scenarios to apply this technology
• Possess basic hands-on knowledge and can read the syntax

I had set out an ideal plan of what I wanted to learn but real life has a way of throwing banana peels to slip on. I adapted my plans, and the following is a summary of my thoughts on each technology I picked up, along with the learning resources I used. Here’s why I picked those subjects:

• Must cover a large surface area. I selected topics around web, backend, databases, and infrastructure.
• I wanted to learn about the clever architectures, designs, and decisions made by people much smarter than I am.
• It would be unlikely for me to use some of those subjects professionally, e.g. Ethereum blockchain programming and Kafka.

12 Days of Learning Topics

1. Aspect-Oriented Programming (AOP)
2. GraphQL
3. Kafka
4. Ethereum Blockchain programming
5. SSIS
6. AWS Lambda with .Net
7. Amazon CloudSearch
8. Terraform
9. React state management
10. PWA
11. SRE
12. GoLang
13. Feature Management

Aspect-Oriented Programming (AOP)

Learning sources:

• This fantastic Dependency Injection e-book

Thoughts:

• AOP is a really interesting technique, which many developers will be uncomfortable with until they encounter the problems that AOP tries to solve
• I am 💯% going to recommend this approach when I come across suitable scenarios

GraphQL

Learning sources:

• Pluralsight: Building GraphQL APIs with ASP.NET Core

Thoughts:

• GraphQL is a useful paradigm in itself, and it makes building web clients so much easier when you can succintly describe the shape of the data you want
• However, it feels very unnatural to integrate it with Entity Framework and SQL Server. I end up introducing another abstraction layer - essentially re-implmenting EF methods in a format GraphQL understands. My many ‘repository’ methods still remain rather than be replaced by GraphQL, which is what I was hoping for.
• I see a bright future for GraphQL-like technologies, but it must be paired with a data store that has native support for GraphQL. I have so far heard of FaunaDB and Dgraph. I might add them to my next learning backlog.

Kafka

Learning sources:

• Pluralsight: Designing Event-driven Applications Using Apache Kafka Ecosystem
• Confluent Community Quick Start

Thoughts:

• Kafka appeared on my tech radar after a presentation by Confluent. I like the idea of a messaging model but Kafka appeared to take this many steps further.
• It is definitely an “enterprise” solution. Entirely overkill for small startups based on the number of servers needed and maintenance required. This can be a niche filled by cloud providers such as Amazon Managed Streaming for Apache Kafka (Amazon MSK) but the pricing is still geared towards customers with cash to spend.
• The possibility of using Kafka to do event sourcing intrigued me but I did not learn how to do this in the course.
• I am especially impressed with how easy it is to use KSQL to set up streams and queries with a SQL-like language.

Ethereum Blockchain programming

Learning sources:

• Pluralsight: Developing Applications on Ethereum Blockchain

Thoughts:

• It was quite easy to get started with learning with a browser IDE like Remix
• The Solidity programming language is close enough to C-based languages which makes it easy to pick-up
• I like Solidity’s blockchain-specific enhancements to the language. They are quite intuitive.
• Truffle framework supports unit-testing Solidity. Yes!
• Ethereum blockchain is secure, but there are still loopholes and you can still write insecure code. It is not automatically secure.
• Cost is calculated based on the amount of ‘gas’ your code needs to run, so it really forces the developer to be efficient.

SSIS

Learning sources:

• Pluralsight: Extracting and Transforming Data in SSIS

Thoughts:

• SSIS has been around a long time but its ease of use and flexibility will ensure its longevity while relational databases are a thing.
• My main concerns are around testability and error handling. It requires very manual testing approaches.
• It has to drag legacy support along, such as multiple database connection drivers and Windows-only runtime, which will exclude it from many people’s minds when starting a greenfield project. It really shouldn’t.
• I can see how it has influenced modern low-code platforms like Zapier and Microsoft Flow (Power Automate).
• I also watched a few clips on Azure Data Factory, and it’s clear they work in tandem, and ADF does not replace SSIS.

AWS Lambda with .Net

Learning sources:

• Official docs, e.g. Building Lambda Functions with C# and .Net Core CLI

Thoughts from someone used to Microsoft Azure:

• Visual Studio (Windows) AWS Toolkit is pretty good - it makes deployment as easy as deploying to Azure Functions
• Lambdas do not have a HTTP endpoint built-in, unlike Azure Functions. I need to bolt on AWS API Gateway to call it. This requires changing how I deal with the default lambda function parameters significantly, which confused me for a quite awhile.
• Resource groups in AWS are an optional construct unlike Azure whereby everything must be in a Resource Group.
• IAM policies are very confusing. I gave up and kept my APIs open. From what I gather, I need to grant permissions on both the calling resource and the called resource, but I’m not sure how to construct the policy code.

Amazon CloudSearch

Learning sources:

• Official docs, e.g. Developer Guide and .Net SDK Reference

Thoughts:

• Documentation for .Net SDK is basic. It is very comprehensive but hard to find what you need. It took me so long to find out where to specify the CloudSearch search endpoint in the SDK (hint: it’s the ServiceURL property of the AmazonCloudSearchDomainConfig class)
• The CloudSearch service itself was easy to get started and configure. I could upload my CSV dataset and it parsed it without trouble.
• The pricing page notes “Pricing is per instance-hour consumed for each search instance, from the time the instance is launched until it is terminated. Each partial instance-hour consumed is billed as a full hour.” The second sentence puzzles me. I interpret it as: if CloudSearch gets exactly one search that takes 5 seconds to execute, Amazon will still charge me for a full hour. This could be an expensive service on a cost per search basis if your site/app only gets a few searches a day.

I used AWS Lambda with API Gateway to expose a REST API to an Amazon CloudSearch domain. This was used to power the item search backend in the Essential Or Not website created by my partner Gage during the SARS-Cov-2 lockdown:

Terraform

Learning sources:

• Official HashiCorp Terraform Getting Started course

Thoughts:

• I like it. It can be hard to justify using Terraform if the organisation is only using one cloud provider, but that’s quite a rare case.
• Azure has ARM templates that work very well, but do not have the state awareness that Terraform maintains.
• The definition language is easy to read, similar to ARM templates but not as nested.
• I can see Terraform relies a lot on ‘magic’ by expecting certain things such as files that must be named a certain way. It can be confusing for a newcomer to pick up all the built-in assumptions that drive a lot of its smarts.
• I did not try any examples that work with on-prem servers, besides provisioning and starting a Docker container.
• State awareness has a downside - you need to maintain it in a central location if you’re working in a team. HashiCorp then tries to upsell you into Terraform Cloud to be the centralized remote state store.

React state management

Learning sources:

• CodeMash Conference 2020 talk: React State: Redux & Context & Hooks, Oh My: CodeMash

Thoughts:

• What annoys me about React is that good state management was not built in to the initial releases, which led to an explosion of different frameworks like Redux, MobX, and StateX over the years. React in itself is simple to learn until you start throwing state at it. That is usually all the time.
• The 40 minute talk by Michael Moran is a useful primer to the most common state management approaches in React but doesn’t go into the nitty gritty. This was perfect for me.
• The summary is:
  • He categorizes state into short-term (user input), medium-term (identity, shopping cart), and long-term (customer data)
  • You can mix and match approaches for different types of state
  • He would use React Hooks if he was starting from scratch today.
  • A useful library of custom hooks is the react-use project

PWA

Learning sources:

• Building Performant Progressive Web Apps from Scratch

Takeaways:

• To paraphrase the instructor, all web apps can be made into Portable Web Apps, but it doesn’t mean that you should. Most apps really need to be rethought in “native” app terms.
• Browser support is growing, however it is still very hidden on iOS. I think it scares Apple that there can be mobile apps that circumvent their tight grip on the App Store.
• The basic implementation steps are pretty straightforward, and the Service Worker approach to support offline mode is probably a good thing to consider in any mobile-optimised app, even without adding to home screen.
• PWAs can be considered a developer specialty because there is decent technical depth required to make production-quality PWAs, especially when it comes to supporting offline workloads.

SRE

Learning sources:

• O’Reilly Webinar Site Reliability Engineering Fundamentals

Takeaways:

• The speakers define Site Reliability Engineering as: SRE is thinking of reliability from a business perspective and engineering towards it. Key term “business perspective” is making sure the reliability solutions you implement help fulfill a real business requirement.
• The analogy they gave was for an airline aiming to be on-time at all times - it will probably lead to over-resourcing and be really expensive, but is it really what the customer expects?
• All systems will fail: What is your acceptable level of failure, and what will you set up to handle it?
• Stripe had “game days” - pick a day to deliberately fail systems to observe impact, practice incident response, and update the run book.
• How reliable should I be? What services touch customers?
• Choose the right SLIs (Service Level Indicators) for the satisfaction of your user. It should be specific, measurable, and actionable.
• SLOs (Service Level Objectives) are your targets for your SLIs, e.g. 98.50% uptime. Consult multiple perspectives to calculate this number, and acknowledge what is realistic, e.g. user internet connections out of your control.
• SLAs (Service Level Agreements) usually involve financial consequences and should not be your SLOs!
• Toil: repetitive, predictable, constant stream of tasks related to maintaining a service. (Google)
• We want to automate toil away, but realize that automation is a spectrum. A simple checklist is also a form of automation and is a step towards fully scripted solutions.
• “The root cause of falling is gravity” perfectly describes why we want to move beyond Root Cause Analysis to blameless Post Incident Reviews.

GoLang

Learning sources:

• Pluralsight: Go: Getting Started

Thoughts:

• I can see why some people like the simplicity of Go. But as the instructor says, simple doesn’t mean easy. It doesn’t provide a lot of ‘magic’ that heavier frameworks like Java and .Net provide out of the box. This means it’s easier to read a Go program and understand the execution flow. I remember my initial confusion with ASP .Net MVC’s routing system, which is largely by convention. Go, however, requires you to implement that logic flow yourself.
• I like that Go discourages the use of panics, which are analogous to exceptions. It instead encourages returning error types. This, again, improves the predictability of the execution.
• THe main thing that feels unnatural to me is how to implement some object-oriented concepts like struct methods and constructors, mainly because they are not actually classes.
• The Pluralsight course was a beginner-level course so it did not go into concurrency, which I keep hearing is one of the main highlights of the language.

Feature Management

Learning sources:

• Pete Hodgson: Feature Toggles (aka Feature Flags)
  • Referenced in that article is a good DevOps cautionary tale
• Pluralsight: Feature Toggles module of this wider course
• Effective Feature Management e-book by O’Reilly and LaunchDarkly
• THAT Conference ‘19: Feature Flags for Better DevOps

Takeaways:

• There are many categories of toggles which affect how they should be stored and managed. The first blog post in my learning sources is a good foundational reading.
• Feature Flags as a Service (FFaaS) is a thing and is quite pricey but there is also a free tier for Azure App Configuration which is fairly new at the time of writing. However LaunchDarkly has a lot of features and integrations with different platforms such as Azure DevOps.
• Feature flags decouple deployment from release, which enables canary releases, dark launches, and A/B testing.
• Architecture patterns need to be considered to avoid tightly coupling your execution code with feature management code.
• “Savvy teams view their Feature Toggles as inventory which comes with a carrying cost, and work to keep that inventory as low as possible.”

And that’s a wrap, folks! I enjoyed doing the 12 Days of Learning because it’s like curating and attending my own conference from the comfort of my own home. I definitely think this is a worthwhile investment for my personal growth - I will continue to organise something like this in the future but for a shorter timeframe, such as a “Long weekend of learning” instead of 12 days.

Updated 8 April 2020 with alternative regex if your OS or framework or app automatically adds the SameSite=Lax header to your session cookies. It is important to double check what your app is emitting so you can tailor the regex to suit!

I just spent a good 6 hours of my life trying to debug a weird web app issue that I finally pinned down to the SameSite cookie attribute changes spearheaded by Google. The change has been signalled for months but I had ignored it, thinking it’s only going to affect niche scenarios that will be updated by other packages. In fact I think this will slowly grow to have the same impact as the TLS 1.0 shut off in 2018 in terms of how many e-commerce website owners are caught out by it.

This was the buggy behaviour I noticed:

1. Users initiated the checkout process
2. Users were taken to a third-party payment gateway to enter their card details
3. The payment gateway sends the user back to the site
4. The web server backend could not retrieve the session cookie, thus treating it as a new user session. This meant that it was unable to retrieve the shopping cart to finalize the order.

I will cover the key points but send you off to more informative sites where necessary. I will then list some mitigating approaches for ASP .Net, my web framework of choice.

Investigation

You need to pay attention to the SameSite changes if your website or application:

• Uses cookies for website functionality. There may be important cookies added implicitly by the framework or imported components. Common ones include cookies that identify session and user preferences.
• Connects to a third-party service, which includes showing their content. Common examples are authentication providers and payment gateways.
• Can be served over non-secure HTTP protocol

In my case, the web application was using ASP.NET_SessionId session cookies to keep track of the user’s details and shopping cart contents. It was also using the Paymark Click hosted payment gateway which Posts to Return URL after payment details are submitted. No SameSite option was set on the ASP.NET_SessionId cookie, so it was treated as “Lax” by default. This meant the cookie was not included when the Paymark Click page sends the POST to the return URL.

Resolution and Mitigation

I highly recommend spending a fruitful 15 minutes reading Rowan’s simple explanation of the SameSite attribute. Start there before implementing any solutions you find so that you understand why you’re doing it. You can also review .Net-specific information in Barry’s blog post announcing the changes.

In my case, my session state cookie needed to have both secure and SameSite=None headers. Luckily my site is HTTPS-only so that solves the secure part, but what about the None header?

ASP .Net 4.7.2 and above, and .Net Core 2.1 and above

Cookies have a SameSite property which can be set to one of three enum values (None, Lax, Strict) according to your needs. However, the default behaviour for “None” varies if you did not specify a value. In the past it would not emit any SameSite attribute, but recent Windows patches will change it to emit the SameSite=None cookie header. More importantly, FormsAuth and SessionState cookies will be issued with SameSite=Lax, which still wouldn’t work properly in my encountered scenario. The Azure App Service was updated with these changes in January 2020.

One approach is to add the cookieSameSite="None" attribute to your web.config:

<sessionState mode="StateServer" cookieSameSite="None" cookieless="false" timeout="20" />

ASP .Net before 4.7.2

The online shopping site I was supporting is built on .Net 4.5.1 which meant that it did not have the same attribute I could specify. Instead, I am using this URL Rewrite (modified off a couple of StackOverlow answers here and here) that applies SameSite=None to ASP .Net session cookies regardless if there’s one:

IMPORTANT! The following solutions require the URL Rewrite IIS extension.

<rewrite>
  <outboundRules>
    <rule name="SessionCookieAddNoneHeader">
      <match serverVariable="RESPONSE_Set-Cookie" pattern="(.*ASP.NET_SessionId.*)" />
      <!-- Use this regex if your OS/framework/app adds SameSite=Lax automatically to the end of the cookie -->
      <!-- <match serverVariable="RESPONSE_Set-Cookie" pattern="((.*)(ASP.NET_SessionId)(=.*))(?=SameSite)" /> -->
      <action type="Rewrite" value="{R:1}; SameSite=None" />
    </rule>
  </outboundRules>
</rewrite>

User Agent Sniffing

There is a huge caveat to the above approaches. Some older browsers do not recognize the None option, and might reject it outright, ignore the header, or treat it as “Strict”. All outcomes will likely cause more problems. Check out Chromium’s post on known incompatible clients for the latest list and UserAgent detection pseudo-code. The web.config solutions I shared above do not have this User Agent sniffing capability, which means it will break the site on affected browsers.

My best solution right now for existing production sites follows. I expanded my IIS URL Rewrite rule to remove SameSite=None header from most incompatible browsers. Kudos to CatchJS for doing real-world testing as documented in their blog: User-Agent Sniffing Only Way to Deal With Upcoming SameSite Cookie Changes . I modified their detection approach into a URL Rewrite pre-condition:

<rewrite>
  <outboundRules>
    <preConditions>
      <!-- Checks User Agent to identify browsers incompatible with SameSite=None -->
      <preCondition name="IncompatibleWithSameSiteNone" logicalGrouping="MatchAny">
        <add input="{HTTP_USER_AGENT}" pattern="(CPU iPhone OS 12)|(iPad; CPU OS 12)" />
        <add input="{HTTP_USER_AGENT}" pattern="(Chrome/5)|(Chrome/6)" />
        <add input="{HTTP_USER_AGENT}" pattern="( OS X 10_14).*(Version/).*((Safari)|(KHTML, like Gecko)$)" />
      </preCondition>
    </preConditions>

    <!-- Adds or changes SameSite to None for the session cookie -->
    <!-- Note that secure header is also required by Chrome and should not be added here -->
    <rule name="SessionCookieAddNoneHeader">
      <match serverVariable="RESPONSE_Set-Cookie" pattern="(.*ASP.NET_SessionId.*)" />
      <!-- Use this regex if your OS/framework/app adds SameSite=Lax automatically to the end of the cookie -->
      <!-- <match serverVariable="RESPONSE_Set-Cookie" pattern="((.*)(ASP.NET_SessionId)(=.*))(?=SameSite)" /> -->
      <action type="Rewrite" value="{R:1}; SameSite=None" />
    </rule>

    <!-- Removes SameSite=None header from all cookies, for most incompatible browsers -->
    <rule name="CookieRemoveSameSiteNone" preCondition="IncompatibleWithSameSiteNone">
      <match serverVariable="RESPONSE_Set-Cookie" pattern="(.*)(SameSite=None)" />
      <action type="Rewrite" value="{R:1}" />
    </rule>
  </outboundRules>
</rewrite>

HTTP Caveat

Chrome will only accept SameSite=None if it is paired with the secure header. Adding that header is not covered in this article, and can usually be added in via different code and config approaches. The secure header also means that the cookie must be served over HTTPS, so make sure your website handles any HTTP redirection as required.

Team culture fascinates me but it often lives as a vague affirmation that “Yes, we want a good culture”. How does that translate into meanigful behaviours and actions? I’ve found that the Team Brand exercise is one possible approach. This is what the team collectively came up with over several months of team meetings (minor tweaks to remove some names):

I asked people’s opinions afterwards and everyone agreed it was a worthwhile effort because we have articulated how the team wants to operate. More importantly, the team took ownership of those values because they defined it themselves. It was not a holy decree commanded down from high above the organisation chart. Having said that, it should still align with the wider company’s vision and values. We’re all moving in the same direction but we’ve decided how we want to get there.

Here’s the summarized version of the Team Brand exercise, which should happen over multiple sessions to allow for thoughts to gestate and evolve. However I have also managed to run through an end-to-end example during a 1 hour talk.

1. Brainstorm words that you want to hear, when other people describe our team.
2. Talk through the qualities and start grouping similar ones together.
3. Do a prioritisation exercise to pick the top 3 or 4 groups of values. I recommend a variation of the Silent Grouping Technique that ranks values instead of sizes them.
4. For each top-level heading, discuss 3 or 4 types of behaviours that we will portray in order to embody those values.
5. Take a break before the final step!
6. Review the values and statements again for a final opportunity to rephrase and re-order.

Reach out to me via LinkedIn if you would like to learn more in detail!

.Net Agent Installation

The .Net Agent Setup on Windows is a breeze to go through. It even installs a Windows application called AppDynamics Agent Configuration that lets you easily re-configure the agent afterwards. I recommend running this right after installation because one of the final steps it does is restart IIS, which is required for the agent to start collecting information about your ASP .Net applications.

Machine Agent Installation

The .Net Agent comes with basic server monitoring features (CPU, memory, disk usage levels). The Server Visiblity license, if you have it, will open up new insights such as detailed Processes list. This means you need to install a Machine Agent on the same server as the .Net Agent. There are a few configuration settings you need to change which you can refer to AppDynamics documentation on .Net Compatibility Mode.

In a nutshell:

1. Set dotnet-compatibility-mode to true
2. Set unique-host-id to the same unique-host-id of the Application. You can find the Application’s unique-host-id by viewing your AppDynamics Agents:

Lastly, it is perfectly fine for the machine agent status to have the “-java-MA” suffix. This means it is running in .Net Compatibility Mode. I also noticed that the status is always INITIALIZING even though it is running normally.

Hope this helps!

ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

This turns out to be a bad move because the code will only support TLS 1.2, while older services may still need TLS 1.1 or 1.0. I found another code snippet that adds TLS 1.2 to the list of supported protocols:

ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;

This approach didn’t work for me because the older OS I was on used TLS 1.0 as the default protocol.

I finally found a comprehensive (if a little confusing) guide in the official Microsoft docs on Transport Layer Security (TLS) best practices with the .NET Framework. The solution for my particular case is to make a Registry tweak to enforce and prefer secure protocols.

Taken from that page, here’s a snippet which can be saved as a .reg file and run on the server. Please be careful when making changes to the Registry, and it is recommended to revisit the official documentation for latest updates.

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\.NETFramework\v2.0.50727]
"SystemDefaultTlsVersions"=dword:00000001
"SchUseStrongCrypto"=dword:00000001

[HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\.NETFramework\v4.0.30319]
"SystemDefaultTlsVersions"=dword:00000001
"SchUseStrongCrypto"=dword:00000001

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v2.0.50727]
"SystemDefaultTlsVersions"=dword:00000001
"SchUseStrongCrypto"=dword:00000001

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v4.0.30319]
"SystemDefaultTlsVersions"=dword:00000001
"SchUseStrongCrypto"=dword:00000001

host {ipAddress}

I needed to use a capture filter because I was running captures on a low-spec server, and without a capture filter Wireshark eats up all the memory.

Related tip: Use nslookup to get the IP address that is resolved to. You would usually do this from the server itself as CDNs may send you to a different IP.

nslookup {www.domain.tld}

Join us next year - check out Datacom Jobs

Pre-requisites

Find a different tutorial if you don’t have these exact components because your results may vary:

1. Windows computer (Windows 10 or newer, or a server edition)
2. DigiCert Certificate Utility
3. Azure App Service that requires a SSL certificate to be updated
4. SSL certificate available to purchase
5. Access to domain name DNS settings

Create certificate

Generate CSR (5 minutes)

1. Open the DigiCert Certificate Utility and follow the official steps to generate a CSR
2. Remember to put a wildcard URL if you are purchasing one.
3. The important thing is you don’t need to generate the CSR on the server that you’re going to install it on.

Purchase certificate using CSR (10 minutes)

1. Purchase the certificate with the CSR generated from DigiCert Certificate Utility. This step is largely similar with all certificate sellers.

Verify domain ownership via DNS (up to 1 hour)

1. As part of the certificate generation process you will need to verify domain name ownership. I recommend using the DNS method, where you add a TXT record with a provided string. This part may take an hour or more to propagate, but is usually faster.

Download certificate (5 minutes)

1. The SSL provider will e-mail the certificate in text format.
2. Copy the certificate text into a text editor and save it with a .cer extension.

Convert certificate into .pfx (10 minutes)

1. Open the DigiCert Certificate Utility on the same server you generated the CSR.
2. Import the .cer file into the server following the installation instructions.
3. Next, export it as a .pfx file following the export instructions.
4. Store the password for the .pfx in a secure manner.

Install certificate on Azure App Service

Upload PFX certificate to Azure (5 minutes)

1. Go to Azure Portal and access one of the App Services you wish to update. Go to the SSL settings blade.
2. Click on Private Certificate (.pfx) tab.
3. Click on Upload Certificate button.
4. Select the .pfx file exported from DigiCert Certificate Utility.
5. Enter the password used to secure the .pfx.
6. Click on Upload. This should take a few seconds. If the notifications say that it is still uploading after a minute, refresh the Portal and upload again.

Assign certificate to SSL Binding (5+ minutes)

1. Go back in the Bindings tab.
2. Scroll down to SSL Bindings section and update each binding with the new certificate.
3. Browse to the site and confirm the new certificate is being used.

Refer to Microsoft documentation because the Azure UI changes often.

I hope this helps someone! Probably myself, in a year’s time.

Background photo credit: University of Glasgow Library on Visual Hunt / CC BY-NC-SA

So how do you eat a giant pumpkin? Piece-by-piece!

It may seem like an uphill climb when staring up a new programming challenge. Honestly it’s a normal feeling among experienced developers like myself. The difference is we quickly start carving that pumpkin up into large segments, otherwise known as a feature breakdown. We ask ourselves some leading questions, like:

• What does the user want to achieve?
• What are we interested within our input?
• Do our inputs have things we want to exclude?
• What are the edge cases?
• How do we start transforming the input into output?

This will effectively chop our pumpkin up into large segments. You can call this a feature, user story, task, etc.

The pumpkin segments are still too large to eat though. You need to break down each segment into even smaller pieces. I ask leading questions like:

• What are our inputs?
• What are our expected outputs?
• What errors might happen here?
• Which parts of the implementation are we writing our own logic, and which are we handing off to another API or library?

This thought process helps to separate distinct parts of the program. For example, you would want to encapsulate your own algorithms away from external API calls. This way you can write unit tests for your own code without worrying about coding against the API. Over time this will break the feature down to individual methods that meet the Single Responsibility Principle. In other words, they are diced into a bite-sized morsels.

I should conclude before I stretch this analogy out too much. New (and old!) software developers should cultivate their pumpkin-dicing skills in order to create applications that are more maintainable and readable. I did not specifically call out any unit test approaches, but this is extremely well-suited to how we can answer that perplexing conundrum: “How do I write a test for a method that does not exist yet?”

Hope you enjoy that delicious pumpkin pie at the end!

Top and background photo credit: aresauburn™ on Visual hunt / CC BY-SA

Pumpkin segments photo credit: Joe Shlabotnik on Visual hunt / CC BY-NC-SA

Diced pumpkin photo credit: Lalibela Ethiopian Restaurant on VisualHunt.com / CC BY-ND

The image above shows a typical WordPress server on the web. The blogger connects to the WordPress administrator console running on the web server to manage content, while site visitors connect to the same server, either directly or via a CDN (Content Delivery Network). The CMS builds the page on-the-fly when a request for a particular page is received.

It is most likely an open-source LAMP stack server, meaning it is composed of Linux (Operating System), Apache (Web Server Software), MySQL (Database), and PHP (Programming language). You can run WordPress on Windows and SQL Server, but a LAMP server starts at $0 licensing costs. This is a major factor for the LAMP stack’s continuing popularity.

A static CMS pushes the page building process up the production line, to when the blogger is writing content. The image below shows a basic static CMS architecture using Hugo. The blogger will create the content on their local environment such as a PC or Mac, and then run the Hugo command-line tool to generate the static .html files. These files are then pushed onto any web server, since all web servers are capable of serving up normal .html, .css, and .js files.

This is certainly adequate and most closely resembles the traditional low-cost WordPress server set up. However, the rise of cloud computing and serverless technologies is creating new possibilities for how we host content-rich websites that are scalable and yet cost very little.

The architecture diagram above shows how I am currently building this blog. I, the blogger, write my content on my Mac and push changes up to a Git repository hosted on Azure DevOps (previously known as Visual Studio Team Services or Visual Studio Online). GitHub is a more popular option, but I am familiar with Azure DevOps and like its all-in-one build and release pipelines.

I use the complimentary build and release minutes included in the free tier. The amount changes from time to time but is currently 30 hours a month, which is more than adequate for my needs. My site is built in the cloud and then released into an Azure Storage Blob account, with static website hosting turned on.

Lastly, I place a CDN service in front of the static website to get the benefits of a cheap, hihgly-scalable, and highly-responsive content delivery system. I have specifically chosen the Premium Verizon CDN offering, and I will explain the reasons why in a future post. A site visitor will be served my content from the closest edge node, so I do not have to worry about distribution or load balancing myself.

The diagram also has an optional App Service API that I have not implemented because I have no need for it. This is another common component of what’s known as the JAMstack - an alternative to the LAMP stack. JAM in this case stands for JavaScript (Programming language), API (Backend), and Markup (Content definition language). There are a lot of well-written information about what makes a good JAMstack on that site. My blog is more a J-Mstack as it stands, but I am considering adding an API layer for site searches.

Next time: I write about how each component is set up.

Minimum Viable Product

I still need to refine many aspects of the blog so what you see as of Dec 31st, 2018 will surely change. I am taking an Agile approach by launching with my MVP (Minimum Viable Product) to gauge interest and refine my product as I go along. Plus, there’s always more motivation to work on a live product rather than one that is stuck in draft forever.

You will most likely read this once I’ve improved on this version, so here are some screenshots of my old WordPress blog and the new blog (as of post date):

Reasons for change

1. I wanted to massively reduce the risk of being hacked since I am not diligent with updating WordPress with the latest patches.
2. I wanted to cut my hosting costs down to the minimum because this is only a personal blog.
3. I wanted to learn new technology.

Current technology stack

• CMS: Hugo
• Editor: Visual Studio Code with Azure Storage extension to simplify static website publishing
• Hosting: Azure Storage with Static Website hosting behind Azure Premium CDN for scalability and managed TLS certificates
• Code repository: Azure DevOps with automated build on master branch updates. I will work on automated releases in the near future.

New journey

I will write more about my migration journey in future posts, especially as I attempt to bundle up the Azure resource configuration into an ARM template that anyone can reuse.

You can also refer to Chris' blog post on Go Make Things on how he migrated his site. Our approaches differ in several key areas, so his experience may be more relevant to your WordPress site setup.

Multitasking

Zumba instructors are fierce multitaskers. Our main job is to dance to the music so that participants can follow along. But we also need to think ahead to what the next move is because we need to inform the class that the change is coming. This is known as pre-cueing and is the next most important thing that group fitness instructors do. At the same time I visually scan the room to make sure that my class members are enjoying themselves and executing the moves safely. There have been instances where I had to get someone’s attention to tell them that their shoelaces are undone. While I kept dancing. And getting ready for move changes.

Tech Leads need to multitask as well. There are very few days where I can sit down and just focus on coding. My weeks are filled with code reviews, preparing statement of works, running meetings, identify roadblocks, and planning resource allocations for upcoming projects. People interrupt me throughout the day for things that they need and it’s my job to be there for them. In fact, I wrote a whole other post about how I recover from context switching.

Role model

I struggle to think of another profession where the term ‘role model’ applies better than to fitness instructors. Class members literally follow my every move for 55 minutes. It is important to be comfortable in front of crowds and be treated as a semi-public persona. I will admit putting on a bit of a character when I change into my Zumba clothes because I represent the Zumba brand, the gym I work for, and my personal reputation.

Tech Leads are role models as well. An individual contributor’s actions reflect back on their teams too, but Tech Leads have an amplified ability to influence perceptions. That is why I think great Tech Leads have to be comfortable with speaking and presenting to a crowd. I believe there are two levels to this.

The first level is to speak to their teams as a group. Tech Leads have the responsibility to shape and influence how technical work is done in the team, and it is more efficient to influence an entire group rather than one person at a time, although that is necessary in certain cases. For example, I did a presentation on the value of unit tests in managing the complexity of legacy code during our team meeting.

The second level is to speak to groups outside their teams. This can be talks inside the company, e.g. brown bag lunch sessions, or talks outside the company, e.g. Meetup gatherings. This is where Tech Leads start presenting an idealized image of their teams and companies, whatever that image may be. In blunt terms, this builds political capital and goodwill for both the Tech Lead and their teams. This makes it easier to attract new talent to the team and increase the Tech Lead’s influence when angling for new opportunities.

Continuous Improvement

Zumba instructors, and all dance instructors by extension, don’t have it easy. Casual observers may think we reuse the same material, but we have to continuously learn new songs and moves to keep our classes fresh. Les Mills programs have an entirely new class every quarter, while Zumba instructors receive about 10 new routines every two months. That’s a lot of continuous improvement. Personally, I aim to learn or choreograph one new song each week because I work better with constant, spread-out effort rather than bursts of intense learning. Either way, we have to keep working to stay in work.

This is no different for Tech Leads. There is no magical finish line when one becomes a Tech Lead. We don’t just sit back with our existing knowledge and start issuing epithets about how developers should write programs. At least, I don’t! On the other hand, there is too much tech to learn all of them in detail. It is a difficult balance because Tech Leads need to stay abreast of different technological trends while also knowing enough about them to make recommendations to the team. The appetite for continuous improvement is required whichever approach one takes.

Conclusion

I hope I’ve demonstrated how two very different professions can require different skills but actually need many similar qualities. I genuinely believe that my experience being a Zumba instructor has helped me navigate my journey to be a top-notch Tech Lead. And I hope you enjoyed the insight into how much work Zumba instructors put in to create a world-class exercise program!

Photo credit: pontla on Visualhunt.com / CC BY-NC-ND

Let the music move you

Music is the key differentiator in most group fitness classes. Music is used to guide the movements in a class, but the influence they have varies on the class format. They range from highly-choreographed affairs for classes like Zumba and BodyPump, then to loosely-guided classes like RPM and Les Mills GRIT, and finally to mood-setting background music for yoga classes.

Zumba instructors are allowed to choreograph their own dance tracks and inject them into their class. I take advantage of this by putting in popular songs and other cool dance tracks that I come across on Apple Music. I pick songs that I know will guide and lift the mood of the class.

A good Tech Lead interacts with his or her team members on a regular basis. My experience with choreographing dance tracks taught me that a person’s emotional state can be influenced from external sources like music. Tech Leads must recognize that they are their team’s external force – they have the power to set the mood if they choose to. This is illustrated clearly in the next section.

Tell me you enjoyed my class

My Zumba classes are 55 minutes long and I have a standard routine after the final cooldown song: I clap my hands to congratulate the class for finishing, say thank you, and ask them to come forward with feedback or questions. I usually get some applause back and a few “Thank you!” from the crowd.

Something special does happen once in a while. I sometimes get first-timers come up to me and say how much they enjoyed the class and how it’s unlike any other Zumba classes they have been to. I also get regulars asking if I teach anywhere else, and that they wished I did more classes at their gym.

I will admit that it makes me feel good about myself. We are taught to be humble and not sing our own praises, but I allow myself some satisfaction that my efforts to lead an enjoyable class were recognized.

This is something that good Tech Leads do as well. They are always on the lookout for the great stuff that their team does, and actively compliment the person or the deed. This does not have to be a loud sing-and-dance in front of everyone else. It can be as simple as a passing comment at the coffee station, or a written note. I would encourage writing it down for future reference if your company does 360° reviews, which Datacom does.

5, 6, 7, 8!

The main job of a Zumba instructor is to lead the class with pre-choreographed moves to music in order to elevate their heart rate for an effective workout. We give minimal breaks because it is important to maintain that elevated heart rate. Therefore, the instructions need to happen during the track and we don’t have the luxury of going through all the moves before a song.

Group fitness instructors use a combination of visual and audio cueing, with visual cues being the preferred option for Zumba classes so as not to interrupt the music. Common visual cues include counting down the repetitions required, direction to travel, and getting the class’ attention when a new move is coming up. This is usually done with my hands, but the facial muscles get a workout too especially when I remind my class to smile and enjoy themselves.

I sometimes put on a microphone if there are more technical moves involved such as when they are facing away from me. This is required if I’m instructing another class like BodyJam where we slowly build up a 30 second routine since there are not enough hand signals in the world to represent all the moves!

The point that Tech Leads should take away is that communication happens via different channels. There are the obvious, conscious ones like e-mails and face-to-face, but there are also unconscious ways like body language and putting on headphones to say that you don’t want to be interrupted. Tech Leads need to be comfortable using multiple communication channels and understand what is being said (or not said!)

Next week

I will finish this post by covering other common things that Zumba instructors do that have helped me become a better Tech Lead.

Photo credit: Lifeline Australia on Visual hunt / CC BY

F# has been around for a long time but many from the C# camp have dismissed it as a niche language for the scientific and mathematic arena. But cross-pollination started bringing functional constructs to C#’s imperative landscape and I clearly remember my first experience with lambda expressions back in .Net 3.5 (2007):

Man, I hate this weird syntax! It looks cool but it isn’t optimised for performance.

I’ve grown to love lambdas over the last decade for its concise and descriptive nature, especially when used in conjunction with LINQ extension methods like Select and Sum, which originated in functional languages. I started thinking about designing for immutability and organising my methods into behaving like functions.

However I have realised that C# will always pale in comparison to a pure functional language because it is too easy to fall back to an imperative and mutable coding approach when things get tough. Hence my decision to look at F# a little closer because it is a solid functional language within the rich .Net ecosystem. Thus begins my functional journey… we’re not in Kansas anymore!

The opportunity presented itself via the Functional Programming Auckland Meetup when they organised a Learn F# Hands-On session. Sam from Coding With Sam was our tutor and he was great in tailoring the content to each learner’s experience level. That real-time feedback and personalised content is something that online courses struggle to match, so I really appreciated Sam’s guidance during and after the session.

(Note: I previously showcased another Functional Programming Auckland Meetup event when I wrote extensively about Functional Reactive Programming)

The session focused on FSharpKoans and that is a great introduction to F# syntax and constructs for people who know a little programming. It is a very gentle and guided tour… until the training wheels come off midway with the Stock example. I’ve read gripes about how some found this difficult but I relished the challenge as it shows who understood the concepts vs. those who were filling in the blanks.

I completed the Koans and have now moved on to exercism.io to continue my F# education. It is a little fiddly to get the initial set up right, but is a great learning platform because you can use your favourite IDE to solve the problems vs. using an online-only solution like HackerRank. The exercises are focused on implementing algorithms while bringing in important techniques such as tail recursion - something I’m still trying to get comfortable with. I like this approach because I need to get comfortable with syntax before I worry about real-world tasks like querying DBs and updating UIs.

Do you know other good learning resources? Sound out in the comments! I will share new resources as I learn about them.

Photo credit: duncan on VisualHunt.com / CC BY-NC

Our modern and busy lives force us to change our focus throughout the day. I find this to be especially true in my role as Tech Lead in a leading IT services company. A key responsibility of mine is to be available to other team members when they need assistance. Hence it is common to be interrupted throughout the day while I’m doing my own tasks. I would stop what I was doing, spend some time with the team member, and then have to stare blankly at my screen for five minutes as I try to piece together what I was doing before I was shoulder tapped. We’ve all experienced that, right? You’re probably nodding your head in agreement!

I recently implemented a system to help me reduce the cognitive burden of context switching. Meet the humble planning diary:

Here is how I use my diary: The first few minutes at work is spent writing out the main tasks I want to complete that day. It is not important to put them in chronological order or go into excruciating detail. In that sense it behaves more like a to-do list. Here’s how a sample day might start off:

8 February (Thursday)

• Architecture diagram for Project E
• Investigate bug J-4
• Team meeting

I tick each off as I finish them or strike it through if I couldn’t get to it that day. I also add tasks to it if I have to do something for a team member to keep myself accountable. This is what my diary might look like at 1pm after Ben asks me to do an urgent code review:

8 February (Thursday)

• ✓ Architecture diagram for Project E
• Investigate bug J-4
• Team meeting
• Code review for Ben

I will also take notes from meetings and write down questions that pop up throughout the day. I went with a small diary to force me to be concise. This is the (slightly) messy result at the end of Thursday:

8 February (Thursday)

• ✓ Architecture diagram for Project E
• Investigate bug J-4
• ✓ Team meeting
• ✓ Code review for Ben
• Meeting notes:
  • Team building event being planned for next month
  • Julie is onboarding a new customer next week
• How to convert VMWare to Hyper-V?

These are the ways a diary has helped me reduce the mental load of context switching:

First, it helps me get back on track after being distracted. I don’t have to try to recall what I was doing before. I will scan my diary instead. The tasks act as mental way finders that usually lead me to where I need to go anyway. In the example above, I might think to myself, “That’s right, I was starting to investigate the J-4 issue, but Ben needed his code reviewed so I did that instead. I need to go to a team meeting soon so I won’t have time to actually investigate the bug. I’ll cross that out and get to it tomorrow.”

Second, any new commitments I make during the context switch is noted immediately without having to change computer windows. Having to minimize the IDE to switch to Outlook just to add a reminder usually makes context switching worse! In contrast, the paper diary is a dedicated screen that is always visible and available, without having to disturb the Zen of my computer workspace. I make time during my break to create calendar invites if necessary, so I get the benefit of automated reminders as well.

Lastly, it helps me review and remember what I did in previous weeks. This is not directly related to context switching but it is still useful! I can barely remember what I had for lunch yesterday, much less the outcome of team meetings a month ago. I also remember things better if I write them down, even if I never refer to the notes again.

In summary, keeping a paper diary has helped me manage the effects of context switching. A low-cost alternative is Post-It notes. You can get most of the benefits by doing the same thing within a single sticky note and sticking it next to your trackpad. That was what I started with. Let me know what other techniques you’ve found useful in the comments section!

Featured Photo credit: Internet Archive Book Images on Visualhunt.com / No known copyright restrictions

Boy, was I right! My original steam iron was a small Warehouse Necessities iron (entry-level home-brand from a big box store, for you non-Kiwi readers). It worked, but not very well. The surface area was small, it didn’t get very hot, and it would drip before it steamed. It was also cheap. The purchase made sense when I got it because I wasn’t wearing that many shirts and I had tight finances.

My requirements have changed seven years later. I always thought some of my shirts were permanently wrinkled. It turned out I just had a crap iron. This experience reminded me that you should always invest in the best tools you can afford. This advice is even truer for software developers.

I’ve come across places that are reluctant to purchase software licenses for developer tools like ReSharper. Instead, the developers scrap together free tools that do sort of the same thing. For example, CodeMaid is a free Visual Studio plugin that has a subset of ReSharper’s cleanup functions. CodeMaid is pretty good if that’s all you can afford, but most commercial developers who have used ReSharper will loathe to go without.

The fact is, ReSharper may not appear ‘cheap’ at $299 per license per year, but it’s only 5% of a junior developer’s annual salary of $60,000 per year. The productivity increase that a good tool provides will surely offset the license cost. So, invest in the best tools you can afford!

There are a couple of caveats to my advice.

First, you can bring the horse to water but you can’t make it drink. Some developers have a prescribed way of working and no fancy tool is going to change them. In that case, giving them a better tool will just be a waste since it’s not used.

Second, and this is for developers, we have to do a better job in highlighting the ROI of a particular tool. We cannot assume that our managers see the same benefits, since they operate at a macro level, so we have to run our own calculations and forecast the return on investment. A common approach is to measure potential time savings with and without the tool. Time is money, after all.

Photo by Ravages on Visual Hunt / CC BY-NC-SA

Let’s quickly recap what the open door policy is. One common explanation is a communication policy where “employees are encouraged to stop by whenever they feel the need to meet and ask questions, discuss suggestions, and address problems or concerns with management”. It’s “intended to foster an environment of collaboration, high performance, and mutual respect between upper management and employees”.

I think the main issue with having the open-door policy is some managers think that it is sufficient to encourage employees to come to them with their issues. My experience over the past 10 years in the industry have taught me otherwise. People are well aware of the policy, but few would actually take the leap to bring a real issue up until it’s critical. And we as managers want to resolve issues before they become serious.

I believe a few of the common reasons why most team members don’t speak up without being asked might include:

• Fear that the open door policy is just lip service, and that they will be ‘punished' for bringing it up.
• There’s an internalised message that managers do not want to hear about problems unless it’s accompanied by a solution. Some problems, by nature, need a manager’s help to solve.
• Unintended consequences of other communication policies like anonymous suggestion boxes and ombudsman processes give the impression that feedback should not be brought up in person, but should be kept hush-hush.

Therefore, an open door policy is insufficient by itself because it is a passive system. It must be accompanied by active systems such as regular one-on-ones where the supervisor is able to create a safe space for the employee to discuss their job satisfaction and air any grievances they have.

Related articles:

• Is Your ‘Open Door' Policy Silencing Your Staff?
• Open Door Policy

Photo credit: boskizzi via Visualhunt.com / CC BY-NC

I’ve always had the impression of military leaders as tough, disciplined warriors who would snap your neck if you even harboured a sense of disagreement. General McChrystal’s early career hinted at that power structure. Note: numbers in [square brackets] indicate the minutes and seconds into the podcast that the transcript begins.

[08:45] I thought that leaders were a command-and-control function. You got information from across your organisation, you use your experience and what intellect you had and aided maybe by (unclear). You made decisions and then you directed those decisions down into the organisation to comply. And if you were a better strategist than your opponent, you would win.

That’s certainly my assumption about the military. I’ve met similar leaders in my IT career. The General understands the temptation.

[14:15] There’s also a human side to it as well. When someone’s put in charge of an organisation, as a leader they think that they’re the best qualified person to make decisions. They’re going to be held responsible for the outcomes so there’s a tendency to want to make the decisions that determine it.

This is where the analogy of the chess master and the gardener comes in. It was mentioned in his book and he summarises it in the podcast:

[47:00] For years I thought that chess master was the best analogy to a successful leader because a chess master controls 16 chess pieces and moves them. And if he or she is a good strategist, they win. And they’re micro-managing each of those chess pieces.

When I got into Iraq I started that way, and then I found that out my opposition Al-Qaeda in Iraq was not a chess master controlling pieces - it was a set of chess pieces that all connected and had relative autonomy. So as a consequence there’s no way one person can defeat a multiple group like that that’s constantly adapting.

So slowly … I realised that gardener is a better analogy for it. Because if you think what a gardener does, a gardener doesn’t grow anything. Only plants can grow things. But the gardener is critical, because the gardener creates the environment. The gardener prepares the ground, the gardener plants, waters, feeds, weeds, protects, and at the appropriate time, harvests. If the gardener does it right, all those plants can do that concurrently, and so suddenly you can scale.

The gardener is completely busy. It’s not a case of empower your subordinates, go home, and let me know how it works. You’re constantly protecting the garden so the garden’s plants are able to do it. And so I believe it’s a less ego-centric way of leading. It takes a little bit of courage to do it because you are allowing your entities to execute. There’s always a chance it’s not going to come out and you’re going to be held responsible. But it’s in my view the only way that will operate in an environment that is changing fast. And it also has the added benefit that people who are doing it with you feel like they are part of us. They don’t feel like they’re employees of the leader.

The gardener analogy really struck me as something profoundly straightforward but also difficult to practice. I definitely didn’t expect that leadership style from a four-star general! One example that illustrates his ‘gardener' approach was:

[23:00] My requirement was to be a connector. My requirement was to move around the organisation, orchestrate conversations, [and] create connections. Much like Steve Wynn did, we did a daily teleconference across the entire command and I was sort of the ringleader for it. I didn’t make a lot of decisions or give guidance but I would make sure that people across the organisation who didn’t know each other and think they had shared equities were connecting because we’re trying to defeat a networked enemy.

The almost 90-minute long interview goes into a lot more detail and I would recommend listening to it in chunks. That is because the interviewing style gets a bit dry without fancy sound editing to avoid audio monotony. It has lots of great content that becomes food for thought.

So: are you a chess master or a gardener?

The massage place (which shall remain unnamed) was in an aging office building. It shared the space with other health and beauty businesses, and the massage room had three cubicles separated by curtains. After signing it at reception I was brought to my massage bed and asked to strip to my underwear. The therapist then left me to undress. I then looked up to see an old heat pump unit that was very clogged with dust. I didn’t take a photo but it was only slightly better than this:

I was honestly shocked at how dirty it was. I proceeded with the massage but I kept thinking about it while the skilled masseur kneaded and stretched my muscles. There’s not much else one can do but think while lying on a massage table!

The next natural thought was, “What other corners are they cutting if they can’t find 5 minutes to give the heat pump a wipe down?” That’s quite a valid concern when you’re half-naked and potentially in contact with what the previous client left behind. This is quite a shame considering the masseur was very talented! But, the little things matter. The simple omission of wiping down the filter regularly has cost them a potential regular customer.

I think back to the world of software development and reflected upon times when the little things mattered. Simple acts like writing code comments, ensuring variables have good names, and writing unit tests do not take much effort but pay huge dividends down the line when someone else debugs your code.

Photo credit: mompl via Visual Hunt / CC BY-NC-ND

The sanitised source code (with the keys and connection strings removed) is on my GitHub repo. Here’s a rough guide on how you can replicate the project and some ideas to extend it further:

Pre-requisites

• A Raspberry Pi 3 running Windows 10 IoT
• Sense HAT module
• Recommended: 40-pin GPIO ribbon cable to keep some distance between the Pi and the Sense HAT because the Pi’s hot running temperature will affect Sense HAT readings
• (Optional) A Belkin WeMo Smart Switch or alternative smart switch that can connect to IFTTT
• (Optional) A dehumidifier that can be turned on from the switch (i.e. does not require additional button presses on the device)
• (Optional) A free If This Then That (IFTTT) account
• Windows 10 PC or laptop is required to build Universal Windows Platform (UWP) apps, which is the platform Windows 10 IoT uses. A Mac OS computer can be used for all other development tasks in this project.
• Visual Studio 2017 (Windows or Mac) Community Edition and above. Make sure to choose UWP Development and Mobile Development options when installing.
• Syncfusion Essential Studio for Xamarin: Syncfusion generously offers free community licenses for individual developers and small organisations.
• An Azure subscription. I stick to free tiers where possible. The only thing I am paying for is Azure Table Storage and it costs about $0.01 a month even after my sensor has been uploading data for a month.
  • Join the Visual Studio Dev Essentials program if you don’t have an existing Azure subscription because it provides free Azure credits over 12 months, along with other great benefits.
• Git clone the Humidity Monitor App source code from GitHub. Make sure it builds successfully on Visual Studio 2017 before proceeding further. This helps validate you have all the required components.

Humidity Logger (UWP)

The Humidity Logger is a simple Windows 10 Universal Windows Platform app that reads the relative humidity sensor on the Sense HAT and uploads aggregated data to Azure Table Storage. This app can only run successfully on a Pi with Sense HAT even though you could launch it in any Windows 10 device.

Azure Table Storage

We first need to create an Azure Table Storage table to load readings in. We will specify three pieces of information - the location of the sensor (e.g. “Lounge”) as the Partition Key, the UTC date time it was inserted as the Row Key, and the relative humidity reading as an integer.

The Row Key is inserted as the number of ticks before DateTime.Max. This results in a decrementing number that I call Reverse Ticks in the code. This was done because Azure Table Storage is a simple NoSQL storage solution that doesn’t have advanced querying or indexing capabilities. It automatically orders records by Partition Key and Row Key in ascending order, which means the record with the smallest Row Key (i.e. the most recently inserted record) is at the top. This makes it trivial to select the latest reading as I just need to read the first record.

Here’s the basic steps to get the Azure Table Storage up and running for the logger:

Log in to the Azure Portal and click on the Add button to go to the Marketplace. Choose Storage account and specify options. I have gone with the cheapest options where possible, including Locally-redundant storage (LRS).

Next, go to Access keys and copy one of the connection strings. We will use this in two places in our code.

Add Connection Strings

The first place to add that Azure Table Storage connection string is in HumidityLogger\MainPage.xaml.cs in the SetUpAndLaunch() method:

actions.Add(new AverageHumidityAction(this, new TableStorageHumidityLogger("TODO - Location code",
    "TODO - Azure table storage connection string", "HumidityLog")));

Also note the need for a Location code. This is used as the Partition Key in the table storage so keep it succinct, e.g. “Lounge”.

Deploy to Raspberry Pi

I find debugging the application is the easiest way to deploy UWP apps onto the Pi. Once that’s done, go into the Pi’s Windows Device Portal and make it the default app to run on startup.

Humidity Monitor API

I’ve decided to create a .Net Core Web API from scratch, as opposed to using the Xamarin project template’s option to generate a Web API backend. I’ve kept the API very simple with only a few supported actions. The main logic revolves around converting DateTime requests to and from the ReverseTicks structure used as the Row Key. Unit tests validate the conversion logic.

Add Connection Strings

Paste the Azure Table Storage connection string from earlier into the HumidityController’s constructor:

public HumidityController()
{
    var storageAccount = CloudStorageAccount.Parse("TODO - Cloud table connection string");
    _client = storageAccount.CreateCloudTableClient();
    _tableName = "HumidityLog";
    _table = _client.GetTableReference(_tableName);
}

Publish to Azure App Service

Go back to the Azure Portal and add a new App Service. Make sure to pick the Web App option, and not the Web App + SQL option.

Specify the App Service options. You may need to create new resource groups and app service plans here. Make sure to create a free App Service Plan to keep costs low. Turn on Application Insights.

Note the App name forms the URL of the API, e.g. humidity-monitor.azurewebsite.net for the example below:

Head back to Visual Studio and use the Publish to Azure option. The UI looks a bit different in Windows but the general flow remains the same.

Visual Studio 2017 has a known bug where it doesn’t detect your subscription. Please try the workarounds in that link if you encounter it.

Humidity Monitor App

The mobile app is built on Xamarin.Forms cross-platform framework using MVVM pattern. I’ve tried to keep everything within the Forms project and avoid platform-specific customisations where possible. I created the project on my Mac, which doesn’t create a UWP variant. However there is no reason why it can’t run on Windows 10 devices as well.

Anyone can create self-signed Android apps for self-distribution, but iOS apps require a developer account to generate valid certificates.

Configure the App

The HumidityMonitorAppViewModel is the main view model driving the mobile app. It has a few important configurations to add in the class fields:

• _location: The location code (i.e. Partition Key)
• TIMEZONE: The IANA time zone code according to NodaTime
• _dal: Requires the base URL of the Humidity Monitor API deployed onto the App Service, e.g. http://humidity-monitor.azurewebsites.net
• (Optional) _switchDal: The IFTTT Maker Webhook key that you obtain from your IFTTT account

public class HumidityMonitorAppViewModel : ViewModelBase
{
    string _location = "TODO - Location";
    private const string TIMEZONE = "TODO - IANA time zone code";
    HumidityViewModel _latestHumidity;
    ObservableCollection<HumidityViewModel> _detailedHumidityCollection;
    ObservableCollection<HumiditySummaryViewModel> _humiditySummaryCollection;
    DateTime _detailedHumidityDate;
    DateTime _humiditySummaryStartDate;
    DateTime _humiditySummaryEndDate;
    bool _canGetLatestHumidity;
    bool _isLoading;
    bool _viewSwitch;
    ViewEnum _currentView;
    readonly HumidityMonitorDAL _dal = new HumidityMonitorDAL("TODO - Backend API base URI");
    readonly IftttDehumidifierSwitchDAL _switchDal = new IftttDehumidifierSwitchDAL("TODO - IFTTT Maker Webhook Key");
    //... more code here ...
}

Create Android Signing Certificate

Follow Xamarin’s guide to generate a self-signed Android certificate. This is mandatory for the next step.

CI/CD with Azure Mobile Center

This is an optional step but one that made my testing life easier because it automatically builds and distributes my Android app on every Git push. The Azure Mobile Center is currently in preview and is free to use. It hooks into your Azure account so make sure to sign in with your existing Azure credentials. There are many guides out there on how to configure CI/CD pipeline with the Mobile Center.

Next Steps for Improvement

Here are some suggested improvements that you can try yourself:

• The Sense HAT has more sensors. Incorporate readings from different sensors, e.g. temperature and pressure, to derive further insights.
• Improve security of the API because you wouldn’t want everyone to be able to see your humidity readings.
• Incorporate the IANA time zone code into the Table Storage so it doesn’t need to be specified on every API call.
• Make the location code configurable in the Humidity Logger UI and Xamarin app so that it can easily support different locations without changing hardcoded strings. The Xamarin app can then be extended to view records from different locations from a drop-down.
• Create configurable notifications that will alert you if the humidity breaches a threshold. This will require building a background service that polls the API at specific intervals. A fancier solution is to do the monitoring on the backend (Azure Functions, maybe?) and send a push notification to the user.

Conclusion

The Humidity Monitor App has many components but I’ve done most of the hard work. All you need is to configure some Azure resources and you’re done. I’ve also left enough gaps in the mobile app for you want to take this further. Enjoy!

It made me reflect on my past choices when designing software solutions. We sometimes take shortcuts, whether due to time constraints or insufficient business analysis. It usually makes us look stupid, sooner or later. No profound lessons in this post. It’s just something to remind me that I should look where I can put in that extra 5%.

Featured photo credit: eilonwy77 via Visual Hunt / CC BY-SA

I was involved in different charities over the years and most of them need boots on the ground – the actual people to carry out the good work. While that is useful, I believe I can do 10x the good if I contribute to their IT systems. Helping the helper, if you will. So, I was extremely chuffed to come across impactNPO who organizes weekend hackathons that bring together IT professionals and deserving non-profits. I finally joined my first impactNPO hackathon last month and want to summarize my experience.

Here’s how the hackathon works – it starts at 6pm on a Friday for charity introductions and networking. Everyone there is a volunteer and most of them meet as strangers. We sign in and get a name tag. We write some acronyms to indicate our area our expertise, such as developer, graphic design, content writer, or project manager. After a quick introduction, we do a ‘speed dating’ session where we spend 10 minutes with each charity understanding their IT needs. We then decide which charity we would like to work with over the weekend, and self-organise into teams. The evening finishes sharp at 8pm because we have early starts for the next two days.

Saturday and Sunday are the main hackathon days, where we work in our teams to build something that will give value to the non-profit we represent. It is essentially a two-day sprint, with a quick review at the start and end of each day, plus a final presentation at 4pm Sunday. I admit that it was both exhausting and exhilarating to try and achieve tangible outcomes for the organisation in just two days with a bunch of strangers I’ve never worked with. I’ve never experienced all five stages of team formation in less than 20 hours – forming, storming, norming, performing, and adjourning!

We had a great product owner in the form of Ina Michaels from The oneCOOPERATIVE. He and the rest of the family of CIDANZ are working hard to create positive outcomes for the Cook Islands community in New Zealand. Through our discovery session on Friday and Saturday morning we pinpointed e-commerce as a main gap in their ability to showcase their craft-makers to the public. We produced a basic but functional oneCOOP online shopping site on VendHQ by Sunday evening.

As for myself, I went in hoping to contribute my development skills but naturally steered myself into a project lead position. I started off with a decomposition and discovery session and the team members had confidence to keep me in that role for the weekend. I had a super time guiding the team towards self-management with Kanban swimlanes, making sure everyone had a chance to contribute, adjudicating conflicts, and clearing out roadblocks. I really felt I made an impact to the world and will not hesitate to participate next time.

impactNPO started right here in Auckland but they are gearing for expansion to other cities in New Zealand, and eventually the world. Check out impactNPO’s Facebook page for all the photos from the weekend and news of upcoming hackathons.

Top photo credit: Palm trees on Aitutaki by chris1h1 via Visual Hunt / CC BY-NC-SA

Let’s get the obvious out of the way: Don’t upgrade existing solutions to ASP .Net Core if there is no need to. It is not worth the trouble as my initial post details. The full .Net framework is very stable, well supported by third-party extensions, and will be in use for years to come. .Net Core as a whole sits on a different trajectory - it was rebuilt from the ground up to support .Net on non-Windows platforms. Even if you wanted to take advantage of that fact to make your existing product cross-platform, I would still suggest taking a long look at your design and architecture. It may be better to start fresh than to upgrade the solution.

Next, start using Visual Studio 2017, now available for both Mac and Windows. You can develop apps on VS Code, but Visual Studio’s extension ecosystem has some great plugins. Most things from Mads Kristensen are good, namely Bundler & Minifier and Web Compiler. Bundler & Minifier creates a bundleconfig.json that lets you bundle and minify CSS and JavaScript files, while Web Compiler does the same for Less and SASS files. Both work similar to Gulp/Grunt without having to install node or npm on your machine.

The other reason I encourage using VS2017 is it finally uses .csproj instead of .xproj/project.json for project files. I found configuring project.json to be finicky at times. Plus the .csproj format has full MSBuild support, which is great news for CI/CD environments. Microsoft has good documentation covering the differences between .csproj and project.json.

Do you use a logging framework such as Log4Net? dotnet core has a generic logging layer that can interface with any other logging framework. However, check that your logging framework can support the appenders that you want to use. As of today, Log4Net doesn’t support AdoNetAppender and SmtpAppender, which are pretty common outputs for logs. Thankfully, Log4Net is open-source so we could use most of their appender implementation but pointing to dotnet core-compatible libraries (native SqlClient for AdoNetAppender and MailKit for SmtpAppender).

Lastly, think about your solution’s external dependencies. Most projects need inputs from the outside world at some stage. You’ll have to think if this will be affected by moving to .Net Core. For example, while I could use Windows Authentication for my intranet web application, I was not able to look up Active Directory details for the given user, such as their full name. Active Directory is a Windows feature and has not been ported over to dot net core. The same concern arises for any old databases you need to connect to - we still have SQL Server 2000 and old IBM DB/2 databases in production. All of these roadblocks can be solved by building your own shim or using a NuGet package, but they represent unexpected roadblocks that will slow .Net Core adoption.

I hope the above points have helped you prepare for most eventualities. Tell me your experience when you start using DotNet Core!

Developer pride manifests itself through three beliefs:

• I recognize the importance of my work because software underpins the backbone of the organisation.
• I take pride in delivering the best solution I can to realize business value.
• I appreciate my fellow developers as the best technical resource I have. I succeed when they succeed.

How does developer pride translate into practices?

• I take time to ensure my work is correct. “It compiles on my machine” is no longer good enough.
  • Are there automated tests? (xUnit, Postman, Selenium)
  • Did I manual test it if there are no integration tests?
  • Written in a way that other devs can understand? (following code standards)
  • Is it documented? (descriptive commit message, Confluence entries, useful comments)
• I put developer ego aside in order to deliver business value.
  • I recognize that “good enough”¹ code is sufficient as long as it doesn’t create technical debt. There’s no need for an over-architected solution or spending 4 hours reducing a 10-line method down to a one-line statement just so I can demonstrate my code-fu.
  • Humans make mistakes. Let’s get on with fixing the problem instead of trying to find someone to blame.
• I am happy to have my code reviewed by my peers, and I will happily do the same for them.
  • Code reviews let me see my code from a different viewpoint. I welcome challenges as it may expose a blind spot.
  • I do code reviews because I want to learn how other developers approach problems. It is not a fault-finding exercise!
  • We review code, not the coder.
• I devote time for continuous personal growth.
  • I explore new toolsets and technologies because even the best knives need sharpening.
  • I take the chance to observe how the business runs because it provides a level of visibility that Kanban/Scrum backlog stories do not. This helps me deliver better business value.
• I communicate with my colleagues with respect² because I recognize them as the best in the industry. This is especially pertinent during disagreements, which is common when many smart minds work on the same problem.

1: “good enough” will be defined by agreed design patterns and coding standards. We can fit an entire program into a single procedural Main() method which works but is probably not good enough by our standards.

2: A fantastic model for verbal communication can be found in Crucial Conversations, which I will blog about soon.

I don’t know if the term developer pride will be adopted by the team, but that is how I intend to carry myself. Do you have pride?

While I have not tried Mob Programming, I experienced Pair Programming at a Code Retreat and finally understood the appeal of collaborative coding. I have subsequently failed to get more people at my workplace to adopt it. Everyone agrees with the concept as if it’s a utopian ideal that ‘good' teams subscribe to, but is impractical in the ‘real world'. I believe those same reasons will prevent mass adoption of Mob Programming.

Realistically, only a small subset of development teams will be able to pull this off. Hence, I’ve started thinking about the attributes that mob members must possess. I don’t see this as a checklist. Rather, each attribute is on a scale and the likelihood of success increases when more members sit on the mature end of the range.

Consider this list the ramblings of an uninformed man. They have not been empirically validated and I invite you to challenge me in the comments section. I may update this list as I grow and read more:

• Relatively young team: I am referring to the age of the team as opposed to individual team members (although that will have a factor as well). Younger teams are more open to new practices, while older teams are more set in their ways. I am not immune – I have caught myself getting defensive when a colleague suggests a different way of doing something. Changing practices that have worked well is a tough ask.
• Crave feedback: Some people are ‘open to feedback' - they will receive your comments but then vigorously defend their own ideas. I am describing a more extreme version where you actively invite and enjoy constructive feedback. This is such an important quality to possess as mob programming is feedback-centric. It’s not going to succeed if members are stressed out and defensive going into a mob. I wished I could say I craved feedback, but I’m working on minimising my ego when I get code reviewed.
• Empathic communicator: Closely related to craving feedback is the ability to give them. Good communication requires many sub-skills and the one I’ve chosen to highlight is empathy. When you have 3 or 4 chefs in the kitchen and only one cook, it’s important that each chef is given the opportunity to infuse the dish with their magic ingredient. I have worked with people who sit somewhere on the autism spectrum and they sometimes miss social cues. They railroad the discussion and it escalates into an us vs. them battle, as opposed to compromising. They may need to be actively managed so that they don’t dominate the conversation, or conversely, feel that they are not being heard.

Those are just some of the soft skills I think a good mob programming team requires. I have not mentioned a single technical skill or process as they are just the icing on a cake made up of those foundational abilities. However, a couple of questions came up during Mark’s talk that he concedes are common questions. They were:

1. How do you convince management that 4 programmers working on 1 problem at a time is better/cheaper/faster than 4 people working on 4 different problems?
2. How is individual performance appraised when work is completed collectively?

Unfortunately, I don’t think his answers are convincing enough to allay management’s fears about adopting mob programming. A good advice I learnt from Tim Ferriss' The 4-Hour Workweek is that it is easier to ask for forgiveness than ask for permission. This may be one of those times where a development team just needs to sneak in mob programming and demonstrate the results at the end.

I will attempt to answer my own question: I think Mob Programming is a long-lived fad. It’s going to be around for a long time just like Pair Programming has: Well-acknowledged but poorly-adopted. Which is quite a shame.

Photo credit: hans s via VisualHunt.com / CC BY-ND

‘In Kentucky, mining veteran Rusty Justice decided that code could replace coal. He cofounded Bit Source, a code shop that builds its workforce by retraining coal miners as programmers. Enthusiasm is sky high: Justice got 950 applications for his first 11 positions. Miners, it turns out, are accustomed to deep focus, team play, and working with complex engineering tech. “Coal miners are really technology workers who get dirty,” Justice says.’

I associate coal miners as blue-collared workers, so is the gap between coal mining and code writing that wide? I used to think so, but barriers to entry are always getting lower. I know a few friends who have created iOS apps and SEO-friendly WordPress sites without four-year Computer Science degrees. Sure, they do not write the most ‘technically beautiful’ code or employ some best practices, but their software works! The ability to automate best practices by default will come sooner rather than later, e.g. Visual Studio’s F5 debug puts your app in a Docker container by default.

I agree with Clive’s long-term prediction that programmers are the next blue-collared job industry. We just need to look at trends such as treating servers as cattle instead of pets, and how the sharing/on-demand economy (_Uber_nisation, as one friend calls it) is disrupting many entrenched industries.

The question we must each answer is: Am I going to keep my head in the sand or am I going to elevate my skills beyond simple coding?

Photo credit: kate.fisher via Visual hunt / CC BY

A couple of clarifications up-front. Introversion and extroversion exist on two extremes of a scale, as a Fast Company article on this topic cleverly summarizes. The same article also gives a comprehensive definition of introversion beyond the stereotypical “introverts are shy”. It is dangerous to pigeon-hole ourselves into one of two boxes, because they simply do not exist. Hence we all have some degree of introversion or extroversion we can exploit.

Secondly, this means there’s no “faking it”, as such. We should always strive to be the most authentic versions of ourselves, and pretending to be someone else just gets exhausting. Authenticity is also required because friendship is a two-way street, and it’s easier to be a friend to others if they can trust the quality of friendship you are providing. In short, these techniques may help introverts amplify whatever minor extroversion qualities they already have.

Making friendships is like making fire. We need kindling to create that initial flame, then add logs to create a strong fire, and renew the logs occasionally to keep the fire going.

Meeting New People

This initial step is always the hardest for introverts. Because true friendships are built through frequent interaction and shared experiences, I recommend two pathways to meet people:

1. Work or school place
2. Hobby or interest social groups

Making friends in school is a no-brainer, but many introverts seem to categorize the office as a different social playground when in fact the usual cliques and hierarchy are present. Although our colleagues are of varied ages and backgrounds, we still share interactions and experiences, two important pieces of kindling. Instead of merely keeping a professional distance, I will look for suitable conversation openings. The ‘fire starters' I tend to use as an opening include:

• Water cooler chat around a topic I know something about, e.g. TV shows, travel destinations I’m passionate for, or the weather (yes, really).
• Genuine compliments about someone’s new look, haircut, or clothes.

Another great pathway is to join social groups as there is the added benefit of already having a mutual interest. In this regards I have to heavily recommend Meetup.com as it revolves around real-life meetups as opposed to interacting behind computer screens. I have joined many Meetups in Auckland mainly for the learning opportunities. I have since realized they are also great for meeting new people outside my normal circles. I don’t need to look for conversation fire starters as they are there by design, regardless if it’s a C# meetup, dog walking meetup, or pasta making meetup.

Conversations

Once the kindling has been lit, we need to start building a fire by placing larger and larger logs. This will happen naturally via continuous interactions, but a key component of these interactions is having conversations. I find this part to be the most mentally draining as an introvert, so I have come up with an arsenal of tools to get me by.

• Mentally prepare a list of questions before the interaction: This is highly effective for very small groups of 2 to 4 people and especially if it’s someone I have met before. I treat them as convenient questions to restart a conversation if we hit a lull, rather than a list of interview questions I must go through.
• Conversation lulls are OK too:  The best friendships are where silence isn’t awkward. Daytime talk shows are the porn equivalent of creating unrealistic expectations of how conversations flow. It’s completely normal to hit the end of a conversation thread with no where to go but start a new one. On the other hand, hitting too many conversation lulls can be a sign that I have nothing in common with this person.
• In a similar vein, I always keep the perspective that good conversations need good speakers and good listeners. I am happy to take a backseat and let other parties speak, instead of worrying about what to say next. I take that opportunity to analyse their words and build a rich profile of the individual in my head. I find that aids the next conversation we have especially if I can recall a particular anecdote.
• Recognise the audience: I tailor my conversations to the relative introversion or extroversion of the group. I prefer to have more personal sessions with my fellow introverts as that is the most comfortable setting for the both of us. On the flipside, I tend to bring in another extrovert when talking to one, as they can feed off each other’s energy and I don’t have to work as hard to keep the conversation flowing.

Maintaining Friendships

This is usually the easiest step. Once a fire is going, one just needs to place fresh logs once in a while to keep it burning. Sure, there may be rain that threatens to wash out the fire, but that’s a different topic. Some friendships are more resilient than others - another friend of mine calls it a ‘cactus friendship' as it doesn’t need much watering to survive. I constantly try to build and sustain such friendships by making sure I make time for them, even in time-poor situations like my current holiday in my birth country of Malaysia.

Faking Extroversion - Summary

1. It is necessary to use our extroversion skills to nurture friendships.
2. The best places to make new friends is at the place we spend most of our waking hours and at social meetups.
3. There are some easy conversation starters and techniques to keep conversations flowing. But, don’t be afraid of lulls either.
4. Friendships need to be maintained. Spending that time together is nourishing, even if it may feel tiring in the short term.
5. Be the most authentic version of yourself and you will attract the right kind of friends. That makes the whole exercise easier.

Photo credit: Stuck in Customs via Visualhunt / CC BY-NC-SA

Some of my highlights this year include:

Starting this Coder on the Frontline blog

I used to maintain a personal blog in my late teens that fizzled out when I started working. I find writing to be quite therapeutic and so decided to start Coder on the Frontline this year. I am normally introverted and this blog has helped me establish my identity as a software engineer and information worker.

Completing my Graduate Diploma in Strategic Management

I started a part-time course via The Open Polytechnic of New Zealand in late 2014, and completed my sixth and final paper in October. It’s been a rollercoaster of emotions getting to this point because I had to make concrete sacrifices (free time with loved ones) for fuzzy benefits (career advancement). Those benefits have not come around, but I learned useful skills that I’m putting to good use. Just like my studies, I will build a solid wall brick-by-brick and get there in the end.

Starting a new job

I started a new job in November which I quite enjoy because I get to learn a new industry and be exposed to some modern tech stacks. Why did I leave my last job? It was a difficult decision to quit as I enjoyed everything I worked on. While I dislike giving credence to stereotypes about Millennials, it is true that I will change jobs if I’m not getting the same value as I provide to the employer. It should be a two-way street in terms of helping each other grow. I believe the middle-class in many developed countries are shrinking, and so I need to be proactive to drive my own growth because there are many more talented people out there who are just as hungry.

Wrapping up for this year

I wish you, dear reader, a wonderful break over the New Year. May you be well and happy. Coder of the Frontline will be taking a well-deserved break until 2017.

Photo credit: flickrolf via VisualHunt.com / CC BY-NC-SA

I learned this one from my previous manager and made a few modifications below. He would ask the candidate to describe his or her favourite project that they have worked on. He will then request for a high-level domain model or class diagram. Follow-up questions are asked depending on the project and the candidate’s level of involvement.

Here are the things that we can learn about the candidate through this single line of questioning:

• Their interest in software development: Some might call it ‘passion’ but I wouldn’t go that far. However, one would still need to show a bit of interest especially at the interview stage. It is hard to show excitement when you’re describing a hypothetical architecture. It’s so much easier to do that when talking about a pet project.
• Tests their ability to explain architecture visually: I find this skill to get more crucial as one progresses in seniority. It’s important to be able to convey your thoughts in a team environment especially if others are doing the implementation.
• Reveals their actual level of involvement in the project: A candidate may be able to wax lyrical about the project, but follow-up questions should aim to uncover their contribution. There are two main forks this conversation can take:
  • “I was responsible for the whole project”: Questions can revolve around how they ensured the quality and who else worked on it. The aim is to know if the candidate is an experienced solo-flyer, a person who prefers to work alone, or worst of all, someone who wings it because they have been working unchecked.
  • “I was responsible for component X”: Questions can revolve around who decided on this architecture and how it integrated with the other modules. This answer can sometimes show that despite their elaborate explanations, they were only responsible for a small portion of the system.

Interviewing is a tricky art as we are trying to ascertain if a candidate will fit an organisation’s needs in only a few sessions between 30 to 60 minutes. The right interview questions can help illuminate multiple aspects of the candidate without directly asking about it. Let me know of any good interview questions you have come across in the comments below!

Start off by seeing her techniques in practice: 5 Reasons We Forget Presentations, then come back here to read an excerpt from the book. It’s from an early chapter and lays the groundwork for the techniques to follow.

A Modern Approach to Memory: The Prospective Model

What are the three most important memory problems you experienced last week? This is a question scientists often ask people when they investigate memory issues more deeply. A series of research studies have found that 60 to 80% of our memory problems are related to forgetting to execute on a future intention. Yesterday you may have intended to give someone a call, send a specific e-mail, or stop by the store to buy milk, and only remembered these today. Some unfulfilled intentions linger for a longer time. How many books have you promised yourself you will reward on your next vacation… for the past five years? We have good intentions but forget to execute on them, or if we remember them, the reward is not compelling enough to get us to act. Our audiences are no different. They listen to us, and they may agree that what we say is helpful. When they leave, they might still remember something from what we had said but don’t do anything about it. We can address that by changing our approach to how we view memory.

Instead of viewing memory as merely recollecting things from the past, let’s look at memory from the lens of the future. This shift is useful for three reasons. First, our audiences’ brains are on fast-forward anyway; as they listen to us now, they are by default anticipating the future. The brain has evolved to be a predictive engine because survival is more likely when one can accurately predict what happens next. We can see evidence of our inclination to anticipate the future in many activities: completing other people’s sentences, salivating before taking the first bite, or laughing just before someone is about to tickle us.

Second, we constantly look to the future to extract value for our present actions. Yale psychologists George Newman and T. Andrew Poehlman have studied the human brain’s tendency to look to the future and identify value for the present. (truncated for brevity)

The third reason it is useful to approach memory with the future in mind comes from communicators sharing content with audiences now, hoping they remember and act on it later. Imagine that we share content at Point A, and we hope people remember and act on it sometime in the future, at Point B. This “future” can be as close as two minutes from now, two days, two weeks, or longer. So, it is pragmatic to ask, what is happening in people’s lives, and what do they intend to do at Point B? If we know this already at Point A, we can prepare for Point B so we can become part of people’s memories and intentions.

Getting people to act on what they remember always starts with an intention – an intention they already have or one you wish to place in their minds. Everyone intends to do something next. Our intentions range from trivial to serious and from automatic to goal oriented. We intend to eat, send e-mails, check Facebook, create documents, revamp a software platform, attend meetings.

TL:DR

The image above is a pretty good summary of this section. We must always be aware of our audience’s intentions. We are sharing the knowledge now but they only need it in the future. How will you make it easy for them to recall your message at Point B? Do check out Impossible to Ignore by Dr. Carmen Simon and make your next public speaking engagement unforgettable!

My first job was with an American multi-national manufacturer. They used a buddy system. All new hires are paired with a buddy on the team who is responsible for showing the new person the “ropes”. This includes where the break room is, how to use the intranet to apply for annual leave, and other such small matters. I was a buddy once and no formal agenda was provided, so it was a case of sharing first-hand knowledge. It was deliberate on-boarding, but not necessarily well-planned.

My next job had an on-boarding plan but I don’t think it achieved its goal of preparing me well. I can’t remember every detail but I recall spending a week just pairing with a senior developer. This pairing was more of watching him code and him explaining why he did certain things, rather than getting to code myself. It was quite tough for the first couple of months until I got a better grasp of the codebase.

A new software development manager came in halfway through my time at this company. He instituted a more formal on-boarding programme that I think ticked all the right boxes. Those boxes are:

• Sessions with individual team members to give them some time with the new employee. This also helps spread the on-boarding responsibility around.
• Spending several days, up to a week, with other teams. In this case, the new developer would spend time with the testing and customer support teams. This gives them exposure to how other parts of the business operate.
• Planned sessions with product owners or business analysts to get a comprehensive tour of the software applications. This helps them understand the product they will be working on from the user’s perspective.
• Regular one-on-ones with the manager to ensure the on-boarding plan is working for them.
• Time and space to do their own reading of company resources.

A plan like the one below is drawn up for each new starter:

<td width="267">
  <strong>What</strong>
</td>

<td width="94">
  <strong>Who</strong>
</td>

<td width="267">
  &nbsp;
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  Company premises tour
</td>

<td width="94">
  Frank
</td>

<td width="267">
  Software architecture and layout
</td>

<td width="94">
  Beth
</td>

<td width="267">
  Rest of the day: Self-explore the knowledge base
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  &nbsp;
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  &nbsp;
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  Source control practices
</td>

<td width="94">
  Jerome
</td>

<td width="267">
  Intro to company applications
</td>

<td width="94">
  Mike
</td>

<td width="267">
  Software release management practices
</td>

<td width="94">
  Sun
</td>

<td width="267">
  Rest of the day: Self-explore the knowledge base
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  &nbsp;
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  (a few more days’ plans)
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  &nbsp;
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  Spend a few hours each day with Customer Support
</td>

<td width="94">
  Kamil
</td>

<td width="267">
  First simple task is assigned
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  &nbsp;
</td>

<td width="94">
  &nbsp;
</td>

<td width="267">
  Work with the testing team
</td>

<td width="94">
  Gretchen
</td>

<td width="267">
  One-on-one to review the first 2 weeks
</td>

<td width="94">
  &nbsp;
</td>

The main advantage of the on-boarding plan is how deliberate everything is. The expectations are set up-front for both the incoming team member and the wider company that they each have a part to play. This is highly crucial because the effectiveness of a team stems from how well they work together. A deliberate on-boarding plan such as the one above maximises the contact surface for the new team member. I truly believe this helps generate early wins for everyone.

I’ve been thinking about induction programmes because I have recently started a new job that did not have the clearest of plans. Consequently, I had to take matters into my own hand and approach team members and other departments directly. I sometimes felt like I was being intrusive because other people did not have an obligation to brief me and they may be caught unawares.

It is to my new co-workers’ credit that they were very welcoming and obliging to my requests. It has been almost 4 weeks since I started and I feel quite prepared and integrated into the team. But that is also thanks to my previous exposure to effective on-boarding programmes and my Strategic Management course. I realised that the best way to assimilate is to talk to people and leverage their strengths.

However, that may not be the case for other new starters, especially if they have just graduated or come from a very different organisation. Hence, having a deliberate on-boarding plan can accelerate their transition from resource consumer to value creator. What is YOUR company doing now to on-board new hires? How can that be improved?

Photo credit: Spongehoe via VisualHunt / CC BY-NC

What are the benefits of formal induction programmes? I think the most obvious advantage is its ability to quickly integrate the new hire into the company culture. A common misunderstanding is that people are merely hired for their skills. Why do we need to induct them since they already have those skills? I have previously mentioned that it’s hard to diagnose your own corporate culture, especially once you’ve been in an organisation for a long time. We tend to forget that, yes, there are other ways of doing everyday things like managing source code, conducting team meetings, and handling disagreements. The new team member will bring his or her own culture, and it is our responsibility to bring them up to speed as soon as possible.

This is even more important in the age of the 90-day trial period in New Zealand. Similar probationary systems exist in other countries. It is to both parties’ benefit that new employees can quickly integrate into the organisation. It does no one any favours if the new person flounders about for three months and the organisation cannot get a good assessment if that person is a good fit for the role. A related great book around this is The First 90 Days wherein the author stresses that new managers have only 90 days to prove their value to the new company. I share that view, and I think that formal induction programmes can help accelerate that.

I was reminded of this topic recently at an Agile Auckland Meetup unconference. A small group of us were interested in how to bring new team members into an Agile team. A couple of answers stuck with me. One manager said he does the bare minimum, rarely taking more than 2 hours, and then lets the new employee loose in the team. His position is that he wants people who are unafraid to speak up and ask for help. I believe he also said that people learn quickest from mistakes. I call that the “throwing them in the deep end” technique. I disagree with him that it is an effective approach, but I understand the logic behind it. I doubt there are many induction programmes that are based around that. I would love to hear more if your team throws new people in the deep end.

Another response was also interesting. The team turns the induction process into a User Story, with the Acceptance Criteria being that the new member commits some production-ready code by the end of the sprint. The User Story is owned by all team members, who then have a stake in helping the newbie learn the ropes. I like the fact that putting it in a story fits into the overall Agile methodology, but more importantly makes clear that induction programmes are a team effort. I still feel it is overly focused on the development process and might unintentionally exclude other crucial elements.

I will write more about my own experiences with induction programmes next week, including one approach that I think ticks all the right boxes. Please comment on other induction programmes you have come across in your line of work.

If you’ve followed the series thus far, you will find writing controller unit tests to be a cinch because you have dependency injection on your ASP .Net controllers. This means the controller itself does not instantiate any of its dependencies such as repositories or business layers. Instead you can use a mocking/stubbing framework such as RhinoMock or Moq to simulate the other layers. I won’t go into detail today as there are great tutorials out there, plus I am starting another series on unit test patterns in the new year.

I will focus instead on how to mock certain bits of ASP .Net ‘magic’ that happens behind the scene. I will give two examples: first for mocking the UrlHelper object and another for mocking the logged in user. Those two scenarios come up quite regularly when crafting controller unit tests.

UrlHelper

There’s a nifty Url helper in ASP .Net Web API controllers whereby you can generate a hyperlink based off the controller action name and any parameters that you give it. This is handy if you’re making Hypermedia APIs as I discussed last week. Imagine you have a POST method and you wish to respond with the link to the newly created user account. This will generate a working link for the action “GetAccountById” with the new ID specified in the route.

//Returns something like http://mybank:8085/api/account/15
Url.Link("GetAccountById", newAccountId)

Here is an example method you can call from controller unit tests that set up the UrlHelper object so it has a route table to reference when running your tests:

/// <summary>
/// Setups the controller for tests, mainly to create a UrlHelper class and register action names.
/// </summary>
/// <param name="controller">The controller.</param>
private void SetupControllerForTests(ApiController controller)
{
    var config = new HttpConfiguration();
    var request = new HttpRequestMessage(HttpMethod.Post, "http://mybank/api/");
    var route = config.Routes.MapHttpRoute("GetAccountById", "account/{id}");
    var routeData = new HttpRouteData(route, new HttpRouteValueDictionary
    {
        {"id", 15}
    });
    controller.ControllerContext = new HttpControllerContext(config, routeData, request);
    UrlHelper urlHelper = new UrlHelper(request);
    controller.Request = request;
    controller.Request.Properties[HttpPropertyKeys.HttpConfigurationKey] = config;
    controller.Request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;

    controller.Url = urlHelper;
}

Logged-in User

The logged-in user is an IPrincipal object as part of the HttpContext in every controller. Here’s one way to mock it, according to a StackOverflow answer:

// create mock principal
var mocks = new MockRepository(MockBehavior.Default);
Mock<IPrincipal> mockPrincipal = mocks.Create<IPrincipal>();
mockPrincipal.SetupGet(p => p.Identity.Name).Returns(userName);
mockPrincipal.Setup(p => p.IsInRole("User")).Returns(true);

// create mock controller context
var mockContext = new Mock<ControllerContext>();
mockContext.SetupGet(p => p.HttpContext.User).Returns(mockPrincipal.Object);
mockContext.SetupGet(p => p.HttpContext.Request.IsAuthenticated).Returns(true);

// create controller
var controller = new MvcController() { ControllerContext = mock.Object };

However, Scott Hanselman has mentioned another way to inject the IPrincipal object into individual methods instead. This would avoid having to mock the HttpContext as well. His blog post talks about passing IPrincipal objects into MVC controllers but I see no problems getting this to work with Web APIs.

Summary

It is certainly quite easy to write controller unit tests if you begin with that end in mind. There are other things in the ASP .Net pipeline model that aren’t as easily tested, but it is my opinion that they are part of the framework. Hence it is the responsibility of the framework provider (Microsoft) to test those, not us developers.

I first came across the term ‘Hypermedia API’ at a job interview when they asked me if I had any knowledge of Hypermedia API. I was honest and replied in the negative. I later looked it up and a more formal acronym is HATEOAS (Hypermedia as The Engine of Application State). A good introductory article is on Wikipedia’s HATEOAS page and I will be paraphrasing from it.

A Hypermedia API is a RESTful API design principle. In essence, it relies on an APIs responses to define and guide the user’s next actions. This is in contrast to using API docs such as those generated by Swagger. A Hypermedia API will return rich media responses, most likely hyperlinks, that more-or-less self-documents.

A good example from the Wiki page is the response when a caller GETs the bank balance of account 12345:

<?xml version="1.0"?>
<account>
  <account_number>12345</account_number>
  <balance currency="usd">100.00</balance>
  <link rel="deposit" href="https://somebank.org/account/12345/deposit" />
  <link rel="withdraw" href="https://somebank.org/account/12345/withdraw" /> 
  <link rel="transfer" href="https://somebank.org/account/12345/transfer" />
  <link rel="close" href="https://somebank.org/account/12345/close" />
</account>

Most APIs will be designed to return just the amount, e.g. 100.00. In comparison, a Hypermedia API returns a list of URLs (the hypermedia) for all the possible actions moving forwards – such as depositing more money or closing the account. There is no need to read an API doc (though they are still helpful as a reference) or formulate a working URL to transfer money as it’s right there in the response.

It should be obvious that it takes a bit of effort and pre-planning to make your APIs HATEOAS-compliant. However, it’s not an all-or-nothing approach. You can still sprinkle some Hypermedia API sugar all over your existing APIs. One place that I used this approach is with any POST or PUT calls. Instead of simply returning the ID of a newly created record, I will return a fully-formed URI to the created/updated resource, like this:

{
    "Message": "The user was created successfully",
    "MessageDetail": "/api/15"
}

Also note how I used the same detailed message response when I wrote about Consistent Response Formats.

Granted, this is nowhere near HATEOAS-compliant but it’s a great start and it’s been really helpful for the testers to write automated API tests because they do not need to keep track of IDs formulate URLs because the resource link is provided right there.

If I had to summarise Hypermedia APIs it is all about understanding how your users interact with your RESTful API and to use that knowledge to create a more pleasant experience. User experience design can still benefit APIs even though it has no graphical user interface.

Photo credit: Abstract Machine via Visualhunt / CC BY-NC-SA

RESTful APIs are meant for external consumption although it does not have a traditional user interface as such. This means it should cater for various user levels, some of whom may not be familiar with the inner workings of the API. Hence, it is important to return useful and clear messages especially when an error occurs. I think this is pretty clear to most developers.

It is more difficult to ensure consistent response formats when there are multiple programmers building a single API. It is also rare for error message phrasings to be specified up-front in this increasingly Agile world. What I have experienced is each coder coming up with his or her own approach to showing error messages. Common formats include:

• Just returning HTTP status codes: I am not a fan of this as it can be open to misinterpretation, especially when it comes to input validation errors (e.g. POST-ing an email address with invalid characters).
• Including a message with the appropriate HTTP status code: This is better, and I suspect is the approach taken by most APIs. This is even provided in the standard HTTP Results types.
• Including a message and detailed message with the appropriate HTTP status code: This is the approach I went for, and the response is a JSON object that looks something like:

{
    "Message": "Input validation errors",
    "MessageDetail": "Please fix the following issues: The email address contains invalid characters and the zip code is missing"
}

I went with this approach to provide two layers of error messages that can be used to drive a visual error dialog. The Message can be used as the dialog box title, while the MessageDetail forms the dialog box content itself.

Alternatively, I could just display the MessageDetail in a Bootstrap status message at the top of the screen. I effectively open up the options for my API consumers to understand the results and consequently display it to their users in the most appropriate manner.

The next step after deciding on a return format that works, is to make it easy for all developers to use it. The most basic way to do this is to create a POCO that has both fields:

public struct ReturnMessage {
    public string Message { get; set; }
    public string MessageDetail { get; set; }
}

Developers can then instantiate a ReturnMessage when a success or error message is desired. This is of course just a starting point. A further extension is to create helper types similar to the IHttpActionResult implementations defined in the System.Web.Http.Results namespace for the most commonly used HTTP codes in your application.

The main takeaway is to make it easy for team members to return consistent response messages. This helps your users and their users down the line. It doesn’t have to be using a ReturnMessage type as I had, but consistent messages go a long way in making a user-friendly Web API.

Photo via Visual Hunt

This week I revisit my post on why we should care about culture. I put forward my argument that we should pay close attention to culture as it affects more than just whether people have work drinks on a Friday afternoon. This was especially relevant to me as I recently interviewed for some new jobs, and the top question of my mind is always, “Will I fit into their culture?” I was also conscious about portraying myself as fitting into the organisation’s culture, by highlighting relevant past experiences. It is something that I look for when I interview candidates, and so I try to make sure they see that when I am on the other side of the table.

Photo credit: Kai Lehmann via Visualhunt / CC BY

This week I revisit my post Cutting-Edge Technology Cuts, where I lambasted ASP .Net Core RC1 for its weak tooling support and how I rolled back to ASP .Net 4.5 with my tail between my legs. It’s now five months since that post and things have only marginally improved with the official 1.0 release. The issue thread on GitHub is still fairly active but it seems it has been noted by the development team in the .Net Core product roadmap. My opinion is now shifting towards using Core 1.0 for experiments to see what it’s all about, but to refrain from full-on production level work until brave pioneers have surfaced other niggly issues with it.

Photo credit: Christian Junker | Photography via Visual Hunt / CC BY-NC-ND

Most projects of a decent complexity will usually need to deal with object to object mapping. This is when an object needs to be converted to another type. Some common scenarios include translating a model to a view-model and flattening a complex object into simple fields for database persistence. This task is traditionally done using a simple mapping method, for example:

public static SimpleDatabaseObject Flatten(BusinessLayerObject blo)
{
    return new SimpleDatabaseObject {
        Id = blo.Id;
        Title = blo.Title;
        CategoryId = (int) blo.CategoryEnum;
    };
}

While this works well, note that the code is pretty simple – all it does is assign some property as-is or cast an enum to an int. A similar method would also be needed if you wanted to convert it back the other way. A disadvantage is apparent once new properties are added – the developer would need to remember to update both methods if it is meant to be mapped back and forth.

Alternatively, convention-based object to object mappers like AutoMapper take the frustration out of this common scenario with simple code like this:

var flattenedDto = Mapper.Map<SimpleDatabaseObject>(someBusinessLayerObjectHere);

This is possible once AutoMapper is configured before the application starts. Registering maps is dead simple if it follows common conventions, but it is also fairly easy to customize mapping. Here is an example for the BusinessLayerObject to SimpleDatabaseObject mapping:

Mapper.CreateMap<BusinessLayerObject, SimpleDatabaseObject>()
.ForMember(d => d. CategoryId, o => o.MapFrom(y => (int) y.CategoryEnum));

Properties that have the same name and compatible types are mapped automatically, such as Id and Title strings. Those that follow conventions happen automagically too, e.g. BookAuthorLastName can be resolved by Book.Author.LastName. Properties that have a different name or special conversion rules will need a bit of help as I’ve shown above.

Using AutoMapper has greatly simplified our Web API development. It is normal for us to expose only a subset of the model through the RESTful interface. There are also rules around how to return certain data types. True, we still need to make sure new properties are added on both the source and destination types, but we only need to configure all the mapping rules in one place.

A practical disadvantage we have encountered is around combining multiple objects into one. I am sure there are ways to configure AutoMapper to do so, but we have found it easier to specify manual mapping methods if we need to construct an object using multiple source objects. The lesson here is to recognise the boundaries of any framework, so we can break away when we need to.

Dependency injection is one particular pattern that implements the Inversion-of-Control principle. To paraphrase Wikipedia‘s excellent page on it, a class should have all its dependencies provided rather than create them itself. For example, you are provided a complete object to use instead of instantiating a business layer object yourself:

public class AwesomeController : ApiController {
    private IBusinessLayer mBusinessLayer;

    public AwesomeController (IBusinessLayer businessLayer){
        mBusinessLayer= businessLayer;
    }

//Logic code that uses mBusinessLayer
}

In this case, your dependency on a business layer object is injected into the controller. Your controller can go on with its life completely oblivious to the exact implementation as long as it matches the IBusinessLayer contract.

The concept of dependency injection is pretty simple. Actually linking it to Web API and MVC is slightly more complicated, however. There are many dependency injection libraries in the market - I personally use StructureMap, but others like NInject work in a similar manner. Because they are platform-agnostic, you still need to hook it up to the overall Web API lifecycle. The general steps are:

1. Configure dependency injection container
2. Configure Web API/MVC/other system components to use the container
3. Use it in your code

I usually struggle with Step 2. The number of custom NuGet packages and blog tutorials out there tell me I’m not the only one. I won’t add to the cacophony as I find each project to be slightly different. This project is using Web API + MVC, while another project used MVC + SignalR. The key thing to keep in mind is that those technologies have built-in support for dependency injection, and it is a matter of finding the right combination of switches. This is what I used in my project to link the same StructureMap container to both MVC and Web API:

public static void Initialize()
{
    SetupService(); //Setup StructureMap mappings
    Resolver = new StructureMapDependencyResolver(Container); //Implements both versions of IDependencyResolver
    DependencyResolver.SetResolver(Resolver); //For MVC Controllers
    GlobalConfiguration.Configuration.DependencyResolver = Resolver; //For Web API Controllers
}

It’s very smooth sailing once the plumbing is hooked up! I add new dependencies in the container and have confidence it gets used correctly anywhere in my web project. My code is now decoupled from my dependencies. (A valid criticism is that I am now dependent on dependency injection, but it’s gotta start somewhere right?)

ASP .Net Core takes this one step further and implements its own simple dependency injection system. This will greatly increase adoption as the difficult Step 2 is more or less removed. However, I am still waiting with bated breath for a stable production version after my last run-in with ASP .Net Core.

Photo credit: SlipStreamJC via Visual Hunt / CC BY-NC

I’ll admit it – I don’t write unit tests as much as I would like to. I’ve only worked at companies with a lot of legacy code that use various levels of automated unit tests. Test-Driven Development (TDD) emphasises writing tests to guide the implementation. Many people consider that as working backwards. I used to be a doubter until I actually tried it for myself. The big advantage of TDD is that it creates testable code up front. A lot of legacy code works fine, but was designed with lots of internal dependencies that make it hard to mock and stub without contorting oneself. This leads to people giving up writing and maintaining unit tests, as the cost becomes too high. Most people mean well – but if the right culture and code conditions are not present unit testing becomes difficult to practice.

I now make it a point to write unit tests where I can. This little FRP project is no different. FRP helped me to unify the logic into one public method which I could unit test vigorously. This is now up on the GitHub project under the 03 – Unit Tests folder. Just a note that I’m using NUnit 3.x, which may require updated test suite runners on your environment.

I also modified the SWidget DateField to expose a Stream property in addition to the existing Cell. I’m not sure if I did it correctly, but I needed a Stream for when the date changes in order to merge() them into a single Stream denoting which date to prioritise. There is slightly different bumping behaviour depending on which date picker the user picked.

The next and final step is to loop the resultant DateRange back into the DateField control. This is one part I’m not sure how to implement. I will need to read the advanced chapters of the book, which I don’t have the time for until I’m done with my Marketing Management course. This is a wrap on FRP for now!

This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.

Photo credit: Pierre J. via VisualHunt / CC BY-NC-SA

Code on GitHub

This week’s fully-functional code is up on the GitHub project, under the 02 – Date Range Picker folder. Each folder corresponds to a week’s post and is self-contained. You will need a .Net 4.6.1 compiler to be able to build and run the project.

Data Availability Dates

One of the control’s external data source is the dates that the system has data for. I am modelling it in a simple way in this exercise by way of a service class. This DataAvailabilityService exposes a Cell of a DateRange. A DateRange is an immutable struct that contains a start and end DateTime. Immutability is an important concept in functional programming, and a good practice to consider in general.

I use a CellSink in this class. A CellSink and StreamSink are the primary ways to sending data into FRP logic. They extend a Cell or Stream with a send() method that pushes data into FRP-land. There is no other way to instantiate a Cell or a Stream without going through the sinks.

In my simple service I have initialised the CellSink with a default value, but I’ve also added a method that simulates fetching new dates from the external world. I am not using this bit yet so we can ignore this for now.

public class DataAvailabilityService
{
    private readonly CellSink<DateRange> mDataAvailabilitySink;

    /// <summary>
    /// Initializes a Data Availability Service
    /// </summary>
    public DataAvailabilityService()
    {
        mDataAvailabilitySink = new CellSink<DateRange>(new DateRange(new DateTime(2014, 1, 1), new DateTime(2016, 07, 31)));
    }

    /// <summary>
    /// Dates that we can run reports for
    /// </summary>
    public Cell<DateRange> DataAvailability
    {
        get
        {
            return mDataAvailabilitySink;
        }
    }
}

Adding date pickers

Once again I am using the SWidget library from the Sodium FRP library book examples. It includes a rudimentary date picker control that consists of three combo boxes, instead of a fancy calendar picker. It exposes a SelectedDate Cell property, which contains the user-selected date.

lift() FRP primitive

lift() is another FRP primitive that works like map() and merge() for multiple cells – you provide a function that combines multiple cells into one. It is called ‘lift’ “because we are ‘lifting’ a function that operates on values into the world of cells.” It is a general functional programming concept that I am still not familiar with.

The bump dates function

Alright – let’s bring all those Cells together and make a smart date picker, shall we? We now have the following Cells:

• StartDate
• EndDate
• DataAvailability
• PeriodType

As mentioned, we will use the lift() function to combine all those cells and output a DateRange.

//Combine the different cells into one DateRange using a Lift() call to BumpDates()
Cell<DateRange> cDateRange = startDateField.SelectedDate.Lift(
    endDateField.SelectedDate, dataAvailabilityService.DataAvailability, 
    cPeriodTypeCell, ReportDateRangeBumper.BumpDates);

The last method argument is a method I’ve defined in a separate helper class.

Date bumping helper function

ReportDateRangeBumper is a helper class that is the logical ham in this FRP sandwich. I won’t go into details as it’s pretty simple once you read it. What’s important is how simple it is – it doesn’t maintain state or have external dependencies. This retains referential transparency and also makes it easy to unit test. In other words, it will always return the same result with the same input parameters.

This is a massive improvement over the non-FRP way of doing things. Previously, I had logic scattered in various event handlers that made it impractical to unit test. I also could not guarantee the order of the events.

Displaying the bumped dates

Finally, I display the bumped dates by using another map() call to convert the DateRange to a string representation. I add this to a SLabel control on the screen.

SLabel selectedDate = new SLabel(cDateRange.Map(dr => dr.ToString()));

//Some other code

ResultsContainer.Children.Add(selectedDate);

Next steps

There are a few important things I still need to figure out. I’ve added TODO notes throughout the code.

• Differentiate between changing the start date vs. the end date picker.
• Update the SDateField once I’ve bumped the selected dates.
• Simulate changing data availabilities while the program is running.

Comments on how to achieve those will be much appreciated!

This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.

My objective over the next few weeks is to reimagine the smart date picker’s data flow/dependency diagram by using FRP primitives. Sodium, the library I am using for this lesson, has ten FRP primitives. There isn’t enough space here to explain each one in detail (I recommend the book Functional Reactive Programming for this purpose), but I will briefly introduce them as I go along.

Today I start implementing the changes to the period type.

Changing the Period Type

This portion of the logic is concerned with how selecting one of the three period types (Weeks/Months/Quarters) registers a change in the Period Type cell, which then flows on to other parts of the program. You may wish to refer to the DFD and cells/streams breakdown covered in previous weeks.

First, we’ll have an enum called PeriodType which has three values: Weeks, Months, and Quarters. Each radio button, when clicked, will output its corresponding enum type. Because the click event is a stream, what we want to do is convert the stream of one type (a click event) to another (PeriodType). This is the basis of the map() primitive. For C# developers who have used LINQ, this is quite similar to the select clause.

We then want to merge the three separate streams into a single stream that will update the cell holding the selected PeriodType. We do this using two aptly-named primitives merge() and hold().

merge() and its close sibling orElse() takes in as many streams as you need but outputs one stream. You provide a function to merge() that combines two streams in some way, whereas orElse() just takes the first stream that occurs. In our case, orElse() would do the job as users will only pick one of the three PeriodType options at a time.

Next, we use a hold() function to store the value passing through the stream as a cell. In this case, we are holding the selected PeriodType. This cell can then be used by other parts of the program such as generating a sales report.

Putting it together

I’ve created a smart-date-picker repository on GitHub for this exercise. They are organised in self-contained folders for each week and I invite you to do a checkout and run it for yourself. I have based it on the SWidgets custom controls that power the book samples, as they have added the necessary FRP hooks to the outside world. This leaves me free to focus on writing the FRP logic.

Check out the folder 01 - Period Type in GitHub. The relevant code bits I added in to a new WPF window are:

public MainWindow()
{
    InitializeComponent();

    //Wrap FRP initialisation code in a transaction
    Transaction.RunVoid(() =>
    {
        //Create selection controls
        SButton weeks = new SButton { Content = "Weeks", Width = 75 };
        SButton months = new SButton { Content = "Months", Width = 75, Margin = new Thickness(5, 0, 0, 0) };
        SButton quarters = new SButton { Content = "Quarters", Width = 75, Margin = new Thickness(5, 0, 0, 0) };

        //Convert click event streams into PeriodType streams
        Stream<PeriodType> sWeeks = weeks.SClicked.Map(_ => PeriodType.Weeks);
        Stream<PeriodType> sMonths = months.SClicked.Map(_ => PeriodType.Months);
        Stream<PeriodType> sQuarters = quarters.SClicked.Map(_ => PeriodType.Quarters);

        //Merge the streams into a single stream with orElse
        Stream<PeriodType> sPeriodType = sWeeks.OrElse(sMonths).OrElse(sQuarters);

        //Hold a value of the stream in a cell, and also specifies Weeks as the default value
        Cell<PeriodType> cPeriodTypeCell = sPeriodType.Hold(PeriodType.Weeks);

        //Display the contents of the cell by mapping it to a string that SLabel can display
        Cell<string> cPeriodTypeString = cPeriodTypeCell.Map(p => p.ToString());
        SLabel lbl = new SLabel(cPeriodTypeString) { Width = 75, Margin = new Thickness(5, 0, 0, 0) };

        //Add controls to WPF StackPanel container
        Container.Children.Add(weeks);
        Container.Children.Add(months);
        Container.Children.Add(quarters);
        Container.Children.Add(lbl);
    });
}

I relied heavily on the book’s RedGreen sample project and SWidgets library to build this. You should note that I have used the provided SButton component instead of implementing my own Sodium-enabled radio button because I want to keep my code simple for now. Nevertheless, they operate the same despite some visual differences.

It looks very different from the usual OOP code one would normally write. I have to say that it does read quite logically from top to bottom when laid out using FRP primitives. The best part? No mutable PeriodType property that can get accidentally overridden without our explicit permission.

Next Week

I will go through a similar exercise with expressing the date pickers and data availability dates using FRP primitives, before combining them together in the following weeks. Comments, questions, and corrections are always welcome.

This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.

Cells

In essence, a Cell is a value that changes over time. Specifically, it is a generic type Cell that can contain almost any type you specify. Other FRP systems might call it a Behavior, Property or a Signal.

The reason Sodium calls it a Cell is because it is conceptually similar to a cell in a spreadsheet. Individual cells in a spreadsheet contain a value but they are not constant. They can change over time, especially in response to changes in other parts of the workbook. Let me illustrate that with Excel’s personal budget template:

This is a simple template where you can put in your income, expenses, and savings. It then shows you a summary for the month with a chart and totals. Let’s trace the precedents and dependents of the Total Monthly Income cell:

It is straightforward. Total Monthly Income is a function that sums up all income sources, and its result is in turn used by the Cash Balance cell to determine how much extra you have left in your bank account. It is also used by the chart data to construct a delicious pie chart. See what happend when I add a new line of income:

When I do that, the Total Monthly Income, Cash Balance, and pie chart are all updated simultaneously. There is no need to manually recalculate because Excel knows the dependency between the cells and so knows the correct order to update them.

This brings us to the concept of Streams.

Streams

A Stream in the world of Sodium represents a “stream of events”. A single mouse click on a button is an event, but multiple mouse clicks on the button throughout the program life cycle would be represented by a stream of mouse clicks.

I find it easiest to think of a Stream as an event handler/listener. I’m sure there are differences between them but I view it as a functional event handler that plugs in to the rest of the Sodium framework. Realistically, one would provide a function that executes when the specified stream fires. This is no different from writing an event handler method but with the added ability to work with Cells and other Sodium primitive operations.

I believe it is called a Stream like the body of water that continuously meanders across the earth. Similarly, a Stream event flows through the program and creates a ripple of changes. In the spreadsheet example above it is logical to conceive of my user input as a stream that leads to other cells being updated.

Smart Date Picker

So what are the Cells and Streams of the smart date picker I am trying to implement? I would look at the data flow diagram I created last week and ponder upon what values are being held and what sources of events are present.

At a theoretical level, I think they would be:

Cells:

• Data Availability Dates
• Period Type (whether it is Weeks, Months, or Quarters)
• Date Range (the selected start and end date for the report)

Streams:

• Select Weeks
• Select Months
• Select Quarters
• Select Start Date
• Select End Date

You might have noticed a few omissions in my cells and streams. I did not put Start Date and End Date as a Cell because ultimately the date pickers are only sources of events. Whatever the user picks are merely a suggestion. The date bumping logic still needs to decide if it is valid, which then updates the date picker and the Date Range cell with the final outcome.

Changes in Data Availability Dates might resemble a Stream, but I did not model it as one because the changes are initiated from outside the application, i.e. database updates. There is a strict requirement of referential transparency in Sodium, which means:

• you must not perform any I/O;
• you must not throw any exceptions unless they are caught and handled within the 
function;
• you must not read the value of any external variable if its value can change, but 
constants are allowed and encouraged;
• you must not modify any externally visible state;
• you must not keep any state between invocations of the function;

(The above list is excerpted from the book Functional Reactive Programming)

Because checking the Data Availability Dates would require I/O (query the DB), it needs to be done outside of FRP. I know you’re asking: How would one integrate FRP into an application that needs to do I/O and throw exceptions? That is a question I have often asked myself as I read the book but the authors insist on keeping those details under wraps until halfway through the book in Chapter 8. This is done under the guise of keeping the reader’s mind ‘pure’ in FRP-Land before the messy reality of integration hits. I have not formed an opinion regarding this approach yet as I’m still reading the book, but will return to this later.

My list of cells and streams for the smart date picker might change as I start implementing it and discover better ways of looking at the problem. Next week: I will write about some of the operational primitives I may need in Sodium to transform cells and streams from one form to another.

This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.

Requirements

Let’s first revisit the smart date picker itself and explain the requirements a bit more. It looks something like this:

This control is used as part of a larger data reporting app. Users select how they wish to view the data – by weeks, months, or calendar quarters. They then pick the dates they wish to run the report for. The start and end dates will automatically adjust (also known as bumping) to ensure a valid report range. Specifically, weeks will always be Sunday to Saturday, months will always go from the first to the end of a month, and quarters will go from the first of a quarter to the end of another quarter.

Test Cases

Here are some test cases (dates in dd/MM/yy):

1. By weeks: Currently showing 12/06/16 (Sunday) to 18/06/16 (Saturday)
   1. Change start date to 29/06/16 (Sunday). It now shows 29/05/16 to 18/06/16.
   2. Change start date to 01/06/16 (Wednesday). It now shows 29/05/16 to 18/06/16.
   3. Change start date to 27/06/16 (Monday). It now shows 26/06/16 to 02/07/16 (bumps both date to ensure a valid range).
2. By months: Currently showing 01/06/16 (first of the month) to 30/06/16 (last of the month).
   1. Change end date to 27/06/16. It now shows 01/06/16 to 30/06/16 (no change).
   2. Change end date to 31/07/16. It now shows 01/06/16 to 31/07/16.
   3. Change end date to 28/02/16. It now shows 01/02/16 to 29/02/16.
3. By quarters: Currently showing 01/01/16 (first day of quarter 1) to 30/06/16 (last day of quarter 2).
   1. Change start date to 15/03/16. It now shows 01/01/16 to 30/06/16 (no change).
   2. Change end date to 15/03/16. It now shows 01/01/16 to 31/03/16.
   3. Change start date to 01/10/16. It now shows 01/10/16 to 31/12/16.

An additional constraint to the basic rules is the amount of data available. It can only show dates for when data can be reported, and bump dates as necessary. The requirements state that this comes from a SQL query, but for the purposes of this exercise, it will be mocked to only have data for 2016.

Extending the test cases above for data availability 01/01/16 to 31/12/16:

1. By weeks: Currently showing 12/06/16 (Sunday) to 18/06/16 (Saturday)
   4. Change end date to 15/02/17. It now shows 12/06/16 to 31/12/16 (Saturday).
   5. Change start date to 15/02/17. It now shows 25/12/16 (Sunday) to 31/12/16 (Saturday).

   </ol>
   

   2. By months: Currently showing 01/06/16 (first of the month) to 30/06/16 (last of the month).
      4. Change start date to 15/02/17. It now shows 01/12/16 to 31/12/16.
      5. Change end date to 20/12/15. It now shows 01/01/16 to 31/01/16.

      </ol>
      

      3. By quarters: Currently showing 01/01/16 (first day of quarter 1) to 30/06/16 (last day of quarter 2).
         4. Change end date to 15/05/15. It now shows 01/01/16 to 31/03/16.
         5. Change start date to 23/08/17. It now shows 01/10/16 to 31/12/16.

         </ol>
         

         There are cases where there wouldn’t be enough data to create a valid range. In those instances, it stops bumping and selects the minimum or maximum date of the data availability.

         Tests might look like this:

         4. Control currently set to Weeks and showing 12/06/16 to 18/06/16. Data only available for 05/06/16 to 30/08/16.
            1. The user changes to Quarterly reporting. It now shows 05/06/16 to 30/06/16 even though it is not a whole quarter because that is the most valid it can get.
            2. The user changes to Monthly reporting. It now shows 05/06/16 to 30/06/16.

         Data and Dependencies

         Those are the general requirements of the smart date picker. I have implemented this in regular C# WPF MVVM architecture, but it produced hard-to-understand code and I ran into issues with some edge cases. I now want to see how it might look like if I redid it using FRP.

         A key difference with functional-style programming is the focus on thinking about the problem in terms of how data depends on each other, and then declaring those relationships in code. This contrasts wildly from traditional imperative-style programming where we tell the computer what we want to do and how to do it.

         It’s been hard grasping FRP concepts because it required me to change my paradigm from thinking about the sequence of events to just focusing on how data relates to each other. I still remember trying to learn object-oriented programming in uni. It threw me into a mental loop because I had been happy using Visual Basic and couldn’t understand why coding objects was “better” than coding modules and forms. And one day I just got it. I suspect the same struggle lies ahead.

         So the first baby step towards thinking in the “problem space”, as the FRP book authors put it, is to map out the data and how they depend on each other. This exercise is surprisingly rare in modern OOP programming even though it’s a logical next step after you have the requirements. Instead, TDD/BDD practitioners jump straight into crafting unit tests that map to requirements, while others segue into defining a sequence of events.

         The data and dependency diagram for the smart date picker might look something like this:

         

         Consider the above a first draft. I might move things around as I understand more FRP.

         This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.

         Photo credit: henk.sijgers (on when I can) via VisualHunt / CC BY-NC

         ]]>https://www.coderfrontline.com/more-impressions-functional-reactive-programming-with-sodium/Sun, 26 Jun 2016 12:27:09 +1200https://www.coderfrontline.com/more-impressions-functional-reactive-programming-with-sodium/I shared a couple of my first impressions reading the Functional Reactive Programming book, and I am back with more after going a bit further with the book. I am spending this weekend in beautiful Queenstown, New Zealand for the Queenstown Winter Festival so this post is shorter than usual. Book Organisation This book is not a ‘cookbook’ – it is not a collection of code recipes you can read and then easily apply in your code.I shared a couple of my first impressions reading the Functional Reactive Programming book, and I am back with more after going a bit further with the book. I am spending this weekend in beautiful Queenstown, New Zealand for the Queenstown Winter Festival so this post is shorter than usual.

         Book Organisation

         This book is not a ‘cookbook’ – it is not a collection of code recipes you can read and then easily apply in your code.

         This book is not a ‘For Dummies’ or ‘Learn xyz in 24 Hours’ book – it is not partitioned into bite-sized chapters that are equally spaced out.

         I would place this book in the intersection between a textbook and a reference book. It is trying to evangelise new concepts and frameworks via large examples, like a textbook. It is also organised in a way that makes it easy to jump back at a later stage to refresh one’s memory, as the core concepts are contained within a single chapter (the previously-mentioned dense Chapter 2).

         The chapters themselves interchange between theoretical chapters and coding example chapters. The note in Chapter 4 summarises my thoughts perfectly:

         “This chapter is quite dense, and we think it will repay any effort you spend on it, but there is no reason why you have to study it all closely now. If it fits your learning style, feel free to read parts of it briefly then carry on with the book and come back to it later.”

         I think this note is equally applicable to the entire book. I wish to clarify that this is not necessarily a negative aspect – the big concepts in life sometimes need a few read throughs to be able to grasp. Do I wish that it was easier to learn? Yes.

         Pro Tip: A lecturer friend of mine once shared his secret to quickly reading lots of academic papers. He scans the executive summary at the front, then jumps to the conclusion at the back to pick out the main gist of the paper. He then reads the main content if he decides there is something worthwhile about it. This tip is very much relevant here. There have been many times that I found the concepts easier to comprehend once I scanned the summary.

         Think of it as a journey: the introduction describes the destination, while the chapter summary describes the journey you were on. Reading these two parts first make the journey itself more enjoyable as your eyes are peeled to spot the landmarks coming up.

         Writing Style

         Thankfully, this is not a dry text. The writing style is quite conversational at times, as if you are reading a series of blog posts. There is also friendly jabbing between the co-authors, almost like the editor’s notes in newspaper articles. Jokes are strewn sparingly around – some clever and some cringey. It definitely helps lighten the mood.

         On the downside, jokes sometimes distract from the learning at hand. Here’s an example from Chapter 2. A note after the explanation of the map primitive said:

         “When my co-author says “more generally” he is invariably trying to trick you into learning functional programming. Don’t fall for it. You can ignore these parts and focus on the examples.”

         Here I was in a serious headspace trying to digest all these new concepts of cells and streams, how streams are like events (but not exactly), how the map primitive transforms streams… and suddenly here’s a jibe about ignoring parts of what I just read. It broke the flow – and I certainly wasn’t laughing. A good joke is as much about timing as it is about the punchline.

         Pro Tip: Most of the notes in this book are meta. I would recommend ignoring them on your first read through.

         This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.

         Photo credit: henk.sijgers (on when I can) via VisualHunt / CC BY-NC

         ]]>https://www.coderfrontline.com/first-impressions-functional-reactive-programming-with-sodium/Sun, 19 Jun 2016 12:26:07 +1200https://www.coderfrontline.com/first-impressions-functional-reactive-programming-with-sodium/This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.This is part of an ongoing series where I review the book Functional Reactive Programming by Stephen Blackheath and Anthony Jones. Kindly note that anything I write here may be incorrect and not indicative of the author’s intent. After all, making mistakes is the mother of learning and this book review is meant to be a truthful reflection of my own experiences grasping a new concept. The review copy I received was version 11 in their Manning’s Early Access Program, so the book’s contents may differ at the time of publication.

         With that pseudo-disclaimer out of the way, I wanted to share my first impressions of the book’s writing style and organisation. I mentioned last week how I stumbled upon Functional Reactive Programming (FRP) and wanted to try implementing a “smart date picker”. I’m just on Chapter 4 and am not ready to start working on that yet. Instead here are some quick-fire thoughts of the book so far:

         What is Functional Reactive Programming?

         This is a comparatively young field and so I appreciate that you, dear reader, may not be familiar with this concept. You’re not alone – neither do I! Instead of trying to come up with a definition that will most certainly be incorrect, I encourage readers to check out the first chapter of this book (see the sidebar). It is free to read and gives a comprehensive overview of where the book aims to take you.

         Sodium FRP and Java

         The authors of the book created their own BSD-licensed FRP library called Sodium, which is implemented in several languages including Java and .Net. The book itself uses Sodium and Java as the main instructional vehicles, even though the concepts should be applicable to other languages and similar FRP libraries. However, my own background as a C# .Net developer makes things slightly less pleasant. While there are many similarities between Java and C#, the differences are like tiny stones stuck in my shoe. Not painful enough to stop walking, but a niggling nuisance nonetheless. Consequently, I find the code samples to be quite verbose from what I’m used to, and I have yet to identify which parts are verbose because of FRP and which are just Java’s eccentricities.

         Pro Tip: The book samples are also implemented in C#, which are all part of the GitHub project. I would recommend running the C# examples instead of the Java ones from the book. If you’re so inclined.

         Target Audience

         This book is targeted towards “programmers familiar with object oriented programming. No prior knowledge of functional programming is needed.” That fits my profile almost perfectly. This is by no means a “For Dummies” book though. It is not ashamed to throw readers like myself in the deep-end, and then stand and laugh as I fumble to stay afloat.

         OK, that last line was a tad melodramatic. I’m only mildly exaggerating of course. While Chapter 1 was a gentle introduction into what FRP is and isn’t, Chapter 2 dives into the primitives that make up an FRP system. I appreciate the use of examples and diagrams to illustrate new concepts such as cells and streams, but I always feel like I am missing something due to a lack of prior functional programming experience.

         There is no time to catch my breath though as the hits keep coming with one concept after another. Looking back, this is one of the densest Chapter 2 of any book I’ve read. This either says something about the depth of this book, or the shallowness of my mind. Take it how you will.

         Pro Tip: Having some awareness of what functional programming is will absolutely help readers understand this book better.

         I will continue sharing more impressions about this book next week and hopefully start working on my date picker widget.

         Photo credit: henk.sijgers (on when I can) via Visual hunt / CC BY-NC
         ]]>https://www.coderfrontline.com/events-are-evil/Sun, 12 Jun 2016 12:57:28 +1200https://www.coderfrontline.com/events-are-evil/<p>Events are evil. Yes, that is quite the incendiary statement to make. To clarify, I don’t mean events in the physical world like rock concerts and art festivals. I am referring to the common event handling patterns most programmers are familiar with, such as button click event handlers and JavaScript callbacks. They are popular because they are simple to set up – most languages support some form of asynchronous event handling out of the box. However, its prevalence does not mean it is perfect, and I have recently come across a different event handling paradigm that promises to rehabilitate events.</p>Events are evil. Yes, that is quite the incendiary statement to make. To clarify, I don’t mean events in the physical world like rock concerts and art festivals. I am referring to the common event handling patterns most programmers are familiar with, such as button click event handlers and JavaScript callbacks. They are popular because they are simple to set up – most languages support some form of asynchronous event handling out of the box. However, its prevalence does not mean it is perfect, and I have recently come across a different event handling paradigm that promises to rehabilitate events.

         I first heard about Functional Reactive Programming last month at an Techweek AKL event. The blurb went like this:

         “Event-based application logic is a special challenge with today’s ever greater demands on the programmer’s art. Functional programming (FP) is a powerful general approach that uses composability to tame application complexity, but event handling has remained tricky. Functional Reactive Programming (FRP) applies functional methods to transform the event handling problem.”

         I’ve certainly experienced my fair share of event handling angst. One of my most recent descent into event handling hell is to implement a pair of smart date pickers that look something like this:

         

         The user picks the date range that they would like a report for. They can constrain it by weeks, months, or financial quarters. The date pickers obey that setting, e.g. if the user is reporting on months, selecting 5 August as the start date will bump it to 1 August. To add another layer of complexity, the user is constrained to picking dates that the system has data for. For example, if the system only has data beginning 3 August, the date picker would be fixed at 3 August even though it wanted to select the first of the month.

         Sounds simple? It started innocently enough but bugs started appearing when unexpected combinations were selected. A big component of the date bumping process is the date picker change event handler that tries to maintain a valid date range. The start date picker’s change event handler can change the end date, which would trigger the end date’s own event handler, which may change the start date, which would trigger the… (and so on and so forth). To avoid an infinite loop, an ‘amnesty’ is used to break the loop, which may leave the date pickers with an invalid range.

         Debugging was also a pain as change event handlers could be triggered from multiple sources, and it’s not clear which event path is ‘correct’. It’s now in a stable state, but god forbid I have to troubleshoot it again!

         That digression serves to illustrate why I was intrigued and went along to the Functional Programming Auckland Meetup on FRP. Stephen Blackheath did a quick-fire demo, implementing a block stacking game in Java using FRP. I will admit that most of the demo flew over my head, as Stephen launched into the code with very little exposition. That is partly due to time constraints and the audience (who are mainly functional programmers familiar with the ‘functional’ way). My experience with functional constructs is limited to C#’s lambda expressions, which I find very useful but not sufficient enough for me to follow along with his demo.

         Of course, one does not need to understand the intricacies of classical art to appreciate the Mona Lisa. So it is with FRP. I was curious about what Functional Reactive Programming might herald, and I was determined to learn more. I approached Stephen during post-event drinks and I offered to review his upcoming Manning’s book on Functional Reactive Programming (co-authored with Anthony Jones). It is currently on the Manning’s Early Access Program, which means it is still subject to revisions. The first chapter ‘Stop Listening!’ is free (check the sidebar), and I highly recommend it to get Stephen and Anthony’s take on why events are evil. The part about the six plagues of listeners is fantastic and provides a solid argument as to why we need to consider new patterns.

         Over the next few weeks I will chronicle my attempt to learn FRP by implementing the Smart Date Picker above using Streams and Cells (FRP primitives). I will rely only on the book, the book’s forum, the Sodium library forum and minimal web searching in order to give an honest book review from the perspective of a developer who’s mainly done imperative coding in C#. I will set up a GitHub page so you can follow my progress.

         Many thanks to Stephen for allowing me to review his book. I am grateful that New Zealand has some great minds doing some great work in emerging areas.

         ]]>https://www.coderfrontline.com/developing-software-on-windows-10-iot/Sun, 05 Jun 2016 09:35:42 +1200https://www.coderfrontline.com/developing-software-on-windows-10-iot/<p>It’s taken me awhile to get into the Internet of Things due to my lack of knowledge around interfacing with the hardware. Luckily, developing software on Windows 10 IoT is almost a breeze for .Net developers thanks to Microsoft’s great tooling support. There are a lot of great tutorials online so I will focus instead on highlighting unique aspects about programming applications for the Raspberry Pi 3.</p>It’s taken me awhile to get into the Internet of Things due to my lack of knowledge around interfacing with the hardware. Luckily, developing software on Windows 10 IoT is almost a breeze for .Net developers thanks to Microsoft’s great tooling support. There are a lot of great tutorials online so I will focus instead on highlighting unique aspects about programming applications for the Raspberry Pi 3.

         Universal Windows Platform

         Commonly shortened to UWP, this is Microsoft’s latest effort to create a common set of system APIs across different Windows devices and architecture. I still remember the circus when Windows 8 introduced Win RT. Time will tell if UWP lasts the distance or gets superseded by the next major Windows release. For the moment though, you will need to create a Universal Windows Platform application in order to run it on Windows 10 IoT.

         UWP provides a rich set of APIs, but it is by no means a complete replacement for the full Windows desktop API. The standard UWP template reveals WPF window classes with standard XAML support – or so it seems. Upon further inspection, UWP XAML is missing some features such as Triggers, which many developers like to use. There are workarounds in both XAML and code-behind, but it is something to be aware of. Namespaces may also differ from what desktop developers are used to, and some UWP-specific NuGet packages might be required.

         Visual Studio 2015 debugging experience

         Visual Studio 2015 provides a first-rate debugging and deployment experience, in all editions. I created a project in both the Ultimate edition I use at work, and the free Community edition on a home laptop. There are no differences between them in terms of working with the Pi. I was able to pick the ARM platform and run it on a Remote Device. It prompts you to pick an auto-detected device, or manually enter an IP address. And it just works – no fiddling with app certificates or manually selecting executables to send over the wire.

         Raspberry Pi remote connection

         One current issue with the auto-detection is that the listening server on the RasPi sometimes times out. It does not show up in the IoT Core Dashboard app and you can’t access the web configuration page either. The running app usually remains operational, but it will need to be soft reset to be able to deploy and debug again.

         Communicating with hardware

         The next step is to communicate with external hardware. This is an area I have yet to investigate in any depth but online code snippets suggest it is quite trivial to send signals to the RasPi’s GPIO pins. I also bought a Sense HAT, which is a convenient add-on board that conveniently sits on top of the Pi and has an 8×8 RGB LED matrix, gyroscope, accelerometer, magnetometer, temperature, barometric pressure, and humidity sensors. Even more convenient is the open-source .Net library created by Mattias Larsson to conveniently poll the Sense HAT’s sensors. It comes with a great samples library to kick-start any Sense HAT project.

         Summary

         While it will always have its detractors, I am personally a fan of what Microsoft is doing in the IoT space and I feel empowered to finally bring my software skills into the hardware world. I will have lots more to write about my experiences with developing software on Windows 10 IoT after I learn more about it. I would encourage you to try it too because the Internet is coming to your things. Are you ready for it?

         For the next few weeks we will completely switch tacks. I received a reviewer’s copy of Functional Reactive Programming, authored by Kiwi technologists Stephen Blackheath and Anthony Jones, creators of the Sodium FRP library. I’m finding time to work through it and will be sharing my thoughts on the book and the pattern itself.

         Photo credit: Caitlinator via Visual Hunt / CC BY

         ]]>https://www.coderfrontline.com/configuring-windows-10-iot-on-raspberry-pi-3/Sun, 29 May 2016 09:06:07 +1200https://www.coderfrontline.com/configuring-windows-10-iot-on-raspberry-pi-3/<p>Configuring Windows 10 IoT is the next logical step after <a href="https://www.coderfrontline.com/installing-windows-10-iot/">OS installation</a>. These tips should apply to any of the boards supported by Windows 10 IoT, but I will focus on the Raspberry Pi 3.</p>Configuring Windows 10 IoT is the next logical step after OS installation. These tips should apply to any of the boards supported by Windows 10 IoT, but I will focus on the Raspberry Pi 3.

         Prerequisites

         Windows 10 IoT is free, but you need a full Windows 10 desktop/laptop environment to get the most out of it. You can access the Pi’s web configuration page from almost any device, but certain steps require Powershell.

         On-Device Configuration

         There are some basic options you can change from within the default startup app. Since this is an IoT device I assume you have a network cable plugged in. This is especially important as there is no way to set the date/time directly. It will instead query a time server automatically, but I have found that it usually takes about 15 minutes for it to correct itself. This is slightly annoying since I don’t have a real-time clock on my Pi. Alternatively, you can also use the Powershell set-date command to manually set the date – useful if your device is not network-enabled.

         You can access some basic settings from this default startup app. The Settings screen will allow you to do the following (as of May 2016):

         • Connect to a broadcasted WiFi network (see below for tips on non-broadcast SSIDs).
         • Activate Bluetooth (RasPi 3 on-board Bluetooth chip not supported as of May 2016).
         • Set the time zone.

         You should also note the assigned IP address on the home page.

         Windows Device Portal

         Windows creates a web configuration page on port 8080. You can browse to it and log in to the administrator account using the default password p@ssw0rd.

         You will obviously want to change that default password immediately and the web configuration will allow that in addition to:

         • Selecting output screen resolution (requires a restart)
         • Running installed apps
         • Install new apps via package uploads
         • Selecting network connection profile
         • Enabling Windows IoT Remote Server – a highly recommended step during debugging and set up. This allows Remote Clients to connect.

         You can get a comprehensive rundown over at Microsoft.

         Windows 10 IoT Core Dashboard

         This is a handy utility especially if you have multiple boards running Windows 10 IoT (lucky you!). You can find the download link in Microsoft’s guide. It lists all the discoverable Windows 10 IoT devices on the network and allows some basic configuration from within the app itself. It can also launch the web configuration portal to save you from remembering IP or machine names.

         

         Windows 10 IoT Remote Client

         Long story short: this is Remote Desktop for Windows 10 IoT. You can’t RDP into Windows 10 IoT (yet) but this app, which can be found in the Windows App Store, allows you to remotely view and control your Raspberry Pi. Highly recommended so you don’t need to connect a the RasPi up to any monitor or TV just to do some minor configuration.

         Connecting to hidden WiFi networks

         By ‘hidden’ I mean WiFi networks that do not broadcast their SSIDs. It’s a bit of a hassle at the moment as there is no interactive way to specify the SSID to look for. I needed to connect the RasPi to my work Wifi (which is non-broadcast) and I came across this excellent guide on importing WiFi profiles through PowerShell. Scroll down to the Option 2 heading and go from there.

         That guide currently advises you to export the desired WiFi profile from the computer you are working on, in order to import it into the RasPi. However, my work PC does not have a WiFi adapter, so I worked around it by using PowerShell to export a saved profile on the RasPi itself. I opened it up in Notepad and tweaked the SSID and WPA2 key, saved it as the new profile’s name, and proceeded to import the profile using PowerShell.

         In case that did not work, here’s a template you can use to roll your own profile. Note that you will need to transmit the Wi-Fi key in plaintext.

         <?xml version="1.0" encoding="US-ASCII"?>
         <WLANProfile xmlns="http://www.microsoft.com/networking/WLAN/profile/v1">
             <name>SampleNonBroadcast</name>
             <SSIDConfig>
                 <SSID>
                     <name>SampleNonBroadcast</name>
                 </SSID>
                 <nonBroadcast>true</nonBroadcast>
             </SSIDConfig>
             <connectionType>ESS</connectionType>
             <connectionMode>auto</connectionMode>
             <MSM>
                 <security>
                     <authEncryption>
                         <authentication>WPAPSK</authentication>
                         <encryption>TKIP</encryption>
                         <useOneX>false</useOneX>
                     </authEncryption>
                     <sharedKey>
                         <keyType>passPhrase</keyType>
                         <protected>false</protected>
                         <keyMaterial> <!-- insert key here --> </keyMaterial>
                     </sharedKey>
                 </security>
             </MSM>
         </WLANProfile>
         

         Microsoft publishes different Wi-Fi profile samples if the above does not suit your Wi-Fi settings.

         I hope the above tips and tricks helped you in configuring Windows 10 IoT for the Raspberry Pi 3. You can expect things to change as Microsoft is actively developing this area. Consider this more of a historical record of how the ‘early days’ looked like.

         Next week: Developing Software on Windows 10 IoT

         Photo credit: “The Wanderer’s Eye Photography” via Visual Hunt / CC BY-NC-SA

         ]]>https://www.coderfrontline.com/installing-windows-10-iot-on-raspberry-pi-3/Sun, 22 May 2016 09:22:28 +1200https://www.coderfrontline.com/installing-windows-10-iot-on-raspberry-pi-3/<p>Installing Windows 10 IoT on a Raspberry Pi 3 can be quite easy… if you take care of a few things up front. I’m wording this blog post from a total newbie’s perspective – someone who might know how to write software, but is taking their first dip into doing IoT in general and Raspberry Pi 3 in particular. If that fits your profile, keep reading.</p>Installing Windows 10 IoT on a Raspberry Pi 3 can be quite easy… if you take care of a few things up front. I’m wording this blog post from a total newbie’s perspective – someone who might know how to write software, but is taking their first dip into doing IoT in general and Raspberry Pi 3 in particular. If that fits your profile, keep reading.

         The first thing you need is a device where you can install Windows 10 IoT on, such as the Raspberry Pi. Microsoft supports other boards as well, but I have gone with the Raspberry Pi (commonly shortened to Raspi) as it’s the most prominent of them. Next, I highly recommend getting the latest model the Raspi 3. Besides having upgraded specs, it now comes with on-board WiFi and Bluetooth. This easily frees up one to two USB ports for other peripherals.

         Tip #1: As of post time (May 2016), Windows 10 IoT supports the on-board Broadcom WiFi chip but not the Bluetooth chip. You should get your own BT dongle if you envision the need to use Bluetooth now, although I’m sure Microsoft will support it fairly soon.

         Tip #2: I found some posts in passing that slammed the choice of embedded WiFi chip on the Raspi 3 as it doesn’t support some advanced features. If you need capabilities such as promiscuous mode, you might benefit from an external WiFi dongle too.

         That’s the hardware part more or less sorted.

         Raspis use SD cards as the main storage by default. Directly installing Windows 10 IoT on a fresh SD card is possible, but I would highly recommend the use of NOOBS (New Out Of Box Software). It fits my needs as a newbie perfectly. Think of it as a NuGet Package Manager for Raspi OSes. It’s a lightweight bootloader that is able to connect to the Internet and download your choice of compatible OSes. Straight off the bat I was able to pick Raspbian (Linux distro with a complete desktop experience) and Windows 10 IoT. NOOBS has got a pretty clever partitioning method that allows multiple OSes on a single SD card.

         Tip #3: To make things even easier for the n00bs among us, you can buy SD cards with NOOBS preloaded on them. I got mine from Pi Shop NZ. I plugged that into my Raspi 3 (which I bought from them too) and it went straight into NOOBS.

         Tip #4: Get a 16GB card or larger. Windows 10 IoT itself takes up almost 8GB which means it won’t fit on a NOOBS 8GB if you want to try other OSes as well.

         Tip #5: If you’re setting your own NOOBS SD card up, make sure to get the fastest SD card you can afford. Not all Class 10 micro SD cards are equal. I found a handy micro SD benchmark geared towards Raspis.

         Once you pick your OS and begin installation (every installation wipes out the entire SD card), you can go get a delicious beverage because the partitioning and installation is quite slow (see Tip 5). Think about 2 hours if you’re doing both Raspbian and installing Windows 10 IoT.

         When it gets to Windows’ turn, NOOBS will direct you to a Windows 10 IoT download page. You will need to login with a Microsoft account, sign up for Windows Insider, and then pick the correct installation for your device. Rather than reproduce the steps here when it’s in constant flux, you should check out Microsoft’s official guide to installing Windows 10 IoT using NOOBS.

         Tip #6: Sign up for Windows Insider before you begin. I had trouble proceeding to the next step when I was doing it via NOOBS and had to restart the whole installation again. It was OK the next time as I was already a Windows Insider member.

         If all goes well, NOOBS should redirect you to the OS selection page where you can pick Windows 10 IoT. This was also the part where I stumbled and required quite a few tries so do read my tips below.

         Tip #7: Initial boot can take a while. However, 2 hours might just be too long to wait. The first time I managed to get to the Windows boot screen, it started at 4am (don’t ask) and it was still going at 6am. I cancelled and restarted the installation.

         Tip #8: On the other hand, some patience is required. On my next installation I was not as patient and pulled the power after a few minutes. This resulted in some corrupt config and it hangs on the Windows boot logo with a cryptic error message. I was not able to fix it and had to restart the installation again. 5 to 10 minutes is a reasonable time to wait.

         

         With lots of luck it should take you into the default app for Windows 10 IoT (hurrah!). You can pick some globalisation settings and connect to WiFi from this startup app, but not much else. Remember, there is no desktop on this Windows and you’ll need to load apps from another Windows 10 machine. This is a topic I will get into very soon. But first, some tips for configuring Windows 10 IoT on the RasPi 3.

         ]]>https://www.coderfrontline.com/windows-10-iot-on-raspberry-pi-3-a-toe-dip/Sun, 15 May 2016 11:04:32 +1200https://www.coderfrontline.com/windows-10-iot-on-raspberry-pi-3-a-toe-dip/<p>Being a software engineering graduate, I’ve always looked at hardware as the other side of the river from me. It sounds a bit surprising considering my first job was at Agilent (now <a href="http://jobs.keysight.com/country-malaysia/#section-overview">Keysight</a>), a top electronics measurement company, but I’ve always treated the hardware component of my work with a little apprehension. However, the Internet of Things (IoT) is becoming very prolific and it’s no longer something I can easily ignore. I’ve thus decided to start dipping my toes in that cold, cold river, beginning with installing Windows 10 IoT on a Raspberry Pi 3. I will share my experiences as I learn more about it.</p>Being a software engineering graduate, I’ve always looked at hardware as the other side of the river from me. It sounds a bit surprising considering my first job was at Agilent (now Keysight), a top electronics measurement company, but I’ve always treated the hardware component of my work with a little apprehension. However, the Internet of Things (IoT) is becoming very prolific and it’s no longer something I can easily ignore. I’ve thus decided to start dipping my toes in that cold, cold river, beginning with installing Windows 10 IoT on a Raspberry Pi 3. I will share my experiences as I learn more about it.

         I consider Windows 10 IoT as Microsoft’s acknowledgement that IoT is poised to start a revolution. They missed the smartphone train, and are barely holding on to their niche in the tablet space (Surface Pro), but they’re definitely taking big steps forward to make sure the Windows brand name lives on in small and headless (zero interface) devices. Thus, Windows 10 IoT is their entry into defining a Universal Windows Platform (UWP) for popular IoT platforms like the Raspberry Pi. Briefly speaking, UWP promises a consistent set of Windows APIs to target, regardless of the device. The idea being that code that targets UWP APIs are platform-agnostic, and should look and perform the same no matter where the code is run.

         Hearing about Windows 10 IoT being available was a great motivation for me to get started. Sure, it’s gotten some bad reviews (takeaway: run!) but that’s inevitable because people expected the full Windows 10 experience. So did I, which meant some disappointment when I discovered there’s no Windows desktop or ability to run multiple foreground apps (slightly ironic considering the Windows moniker – what? No windows?).

         However, that overlooks some key points. The main one for me is that I can use development tools (Visual Studio 2015), languages (C#), and frameworks (WPF) that I’m familiar with onto a new platform. I plan to get around to developing on Linux, like on the excellent Raspbian distro, but I see Windows 10 IoT as helping to remove a major barrier between ideas and implementation.

         I highly doubt I would get started without having Windows 10 IoT because there is just so much to consider when doing IoT – different processor architecture, resource constraints, communicating with external sensors/peripherals, and finally the software. I felt that Windows 10 IoT gives me a confident footing with its software platform (as feature-lite as it still is), and so I can focus more on the other pillars of what makes up IoT. I suspect this is the same for a lot of software developers who are already struggling to learn about breadboards and resistor colour codes, which bodes well for Microsoft if they can quickly solidify the Windows 10 IoT development experience.

         I will be sharing my experiences with developing on the Raspberry Pi 3 over the next few weeks, and what you should watch out for.

         ]]>https://www.coderfrontline.com/techweek-akl-14-22-may-2016/Mon, 09 May 2016 03:55:08 +1200https://www.coderfrontline.com/techweek-akl-14-22-may-2016/<p>The first ever <a href="http://techweek.co.nz/">Techweek AKL</a> starts in less than a week and I&rsquo;m excited to attend some of the events. I think it&rsquo;s a great start to building NZ&rsquo;s tech resources. Sure, it&rsquo;s no TechCrunch Disrupt but this will definitely start us down that path. However I don&rsquo;t think it&rsquo;s very well publicised as I only found out about it while glancing through the last <a href="http://ourauckland.aucklandcouncil.govt.nz/">Our Auckland newsletter</a>. Consider this my small part in raising its visibility.</p>The first ever Techweek AKL starts in less than a week and I’m excited to attend some of the events. I think it’s a great start to building NZ’s tech resources. Sure, it’s no TechCrunch Disrupt but this will definitely start us down that path. However I don’t think it’s very well publicised as I only found out about it while glancing through the last Our Auckland newsletter. Consider this my small part in raising its visibility.

         Techweek AKL has various events that help you “immerse yourself in the latest STEM trends from nanotech to biotech, from the Internet of Things to virtual reality, from the on-demand economy to peer-to-peer business.” While it’s not a programming-centric event, software will undoubtedly be a major driving force behind those new breakthroughs. Hence I think it’s helpful for software developers to check out some of the events and network with current/future industry leaders.

         Unfortunately there is a cost involved in many of the main keynote events as they involve international speakers. I am a bit cash-strapped at the moment so have focused my attendance on the free events. Come say hi if you see me at the following Techweek AKL events:

         • 16 May (Monday) 5-8pm: The Connected City with Nokia and JLL
         • 17 May (Tuesday) 6-9pm: Functional Reactive Programming in Java with Sodium

         There are many others I would like to check out but they happen during working hours or have a decent cost involved. I highly recommend checking out the Ethereum - Disrupting the Global Financial System mini-conference ($280!).

         Photo credit: Lambroso via Visual hunt / CC BY-SA
         ]]>https://www.coderfrontline.com/strategy-lenses-how-strategy-is-formulated/Sun, 08 May 2016 01:18:46 +1200https://www.coderfrontline.com/strategy-lenses-how-strategy-is-formulated/<p>I wanted to do a quick add-on to last week’s post about the many <a href="https://www.coderfrontline.com/definitions-of-strategy/">definitions of strategy</a>, specifically: How is strategy formulated? Again, many perspectives abound and one approach is the strategy lenses, as found in <a href="http://amzn.to/1X1hV7x">Exploring Strategy 10^th edition</a>. In it, the authors present various ways of comprehending strategy development, and they can be loosely linked to <a href="https://www.coderfrontline.com/definitions-of-strategy/">Mintzberg’s 5 P’s of strategy</a> I covered last week.</p>I wanted to do a quick add-on to last week’s post about the many definitions of strategy, specifically: How is strategy formulated? Again, many perspectives abound and one approach is the strategy lenses, as found in Exploring Strategy 10^th edition. In it, the authors present various ways of comprehending strategy development, and they can be loosely linked to Mintzberg’s 5 P’s of strategy I covered last week.

         The below text is excerpted from  Exploring Strategy 10^th edition with some of my own analysis thrown in:

         Design Lens

         The design lens views strategy development as a logical process of analysis and evaluation. This is the most commonly held view about how strategy is developed and what managing strategy is about. It encourages objective analysis through the use of formal concepts and frameworks.

         This matches most closely with the strategy as plan and strategy as ploy definitions. It is definitely what most business consultants recommend, since their bread-and-butter is convincing clients that they can plan their way to success with a few choice tools like a SWOT Analysis.

         Experience Lens

         The experience lens views strategy as the outcome of people’s taken-for-granted assumptions and ways of doing things. Given that strategies are chosen and implemented by people, then their experience is going to matter. Strategy through the experience lens puts people, culture and history centre stage in strategy development.

         This can be linked to the strategy as perspective viewpoint. It emphasises that effective strategy cannot be simply designed on paper. Instead, it has to take into account what the existing people (the agents) are comfortable with and are able to carry out.

         Variety Lens

         The variety or ideas lens views strategy as the bubbling up of new ideas from the variety of people in and around organisations. Top managers cannot know everything about their organisations and markets. According to the variety lens, therefore, strategy can emerge not just from the top, but also from the periphery and bottom of the organisation.

         Similar to the previous lens, it puts the spotlight on the ‘coal face’. They are the closest to the ground and so can often be able to give feedback on what’s working and what’s not. Unfortunately, most strategy development happens at the top because it’s commonly viewed as the job of ‘senior managers’. In short, this lens encourages strategists to look outside of themselves.

         Discourse Lens

         The discourse lens views language as important both for understanding and changing strategy and for managerial power and identity. Managers are always using language to pursue their objectives. Through this lens, unpicking managers’ discourse can uncover hidden meanings and political interests.

         I was most intrigued by this lens because it put a label to something I had long suspected – that strategy development is influenced by communication, especially communication that comes with interests and biases attached. This is inevitable as strategy changes have an effect on people for better or worse. Some of them, you might expect, would try to manoeuvre strategy to their advantage.

         Footnote

         I hope you enjoyed reading about the different strategy lenses, and appreciate that they can be approached from many ways and yet be correct. The key implication is to always consider other lenses and definitions. Strategy is an exciting field and it doesn’t need to include a single SWOT Analysis!

         ]]>https://www.coderfrontline.com/clash-of-culture-mediaworks-and-mark-weldon-part-ways/Wed, 04 May 2016 01:00:25 +1200https://www.coderfrontline.com/clash-of-culture-mediaworks-and-mark-weldon-part-ways/A clash of culture happens when cultures don&rsquo;t mesh - and the resulting fireworks can be very dangerous. It gives further reason to care about culture and how one&rsquo;s personal culture can affect the entire organisation. Some choice excerpts from NZ Herald - 4 May 2016 article on Mark Weldon&rsquo;s resignation (all **emphasis **is mine): “People in that company actually love that company. The issue for Mark is that he wasn&rsquo;t really a cultural fit.A clash of culture happens when cultures don’t mesh - and the resulting fireworks can be very dangerous. It gives further reason to care about culture and how one’s personal culture can affect the entire organisation. Some choice excerpts from NZ Herald - 4 May 2016 article on Mark Weldon’s resignation (all **emphasis **is mine):
         • “People in that company actually love that company. The issue for Mark is that he wasn’t really a cultural fit. He, for his own reasons, wanted to develop a culture that he believed in but it ran very contrary to the culture that existed there - and it was always going to end up in a tough situation.” - Mark Jennings (former MediaWorks news chief)
         • Former weekend newsreader Carolyn Robinson tweeted: “Goodbye Weldon. Don’t trip on the ruins you created as you leave.” Former Campbell Live producer Pip Keane posted: “It’s definitely a karma day.”
         • “People work very much for each other. That seemed to be very different to the way Mark saw things.”
         • “The culture was a no blame culture. If something did go wrong we all accepted responsibility for it. It wasn’t a culture to single people out. It meant we were close and people were always prepared to go over and above what they were paid for and what was expected of them. The hard thing for me was to see people drop off that.”- Mark Jennings

         Allow me to defend Mark on some of those issues. He came in when MediaWorks was on the brink of bankruptcy. People (the Board and creditors) expect swift action during a crisis, and that’s exactly what he provided. There is little time to sit around and do feasibility studies on a rescue mission when the ship is rapidly sinking! And while I acknowledge that MediaWorks looks like it has a great culture (the no blame culture is similar where I work), we have to be honest - it’s not producing the results required to sustain itself. I can imagine Mark pinpointing the culture as something that needs to change, but perhaps he went too far or off-course.

         Will acting CEO David Chalmers continue Mark’s strategy or dial it back down to avoid another clash of culture? Time will tell I suppose. For now (and in conjunction with May the 4th), may the force be with Mark’s next endeavour.

         ]]>https://www.coderfrontline.com/the-many-definitions-of-strategy/Sun, 01 May 2016 02:38:17 +1200https://www.coderfrontline.com/the-many-definitions-of-strategy/<p>What is strategy in a business context? That is an even more elusive question than <a href="https://www.coderfrontline.com/culture-re-introduction/">what culture is</a>. I always thought strategy meant market positioning, but my recent academic foray has exposed me to the many definitions of strategy. I list them below, and while some may contradict another, they are in fact all correct. How can that be, you ask? I reckon it is similar to light and sound, which can behave like a wave or a particle under different circumstances (the <a href="https://en.wikipedia.org/wiki/Wave%E2%80%93particle_duality">wave-particle duality</a>). To paraphrase Einstein, the different definitions of strategy present “<em>contradictory pictures of reality; separately neither of them fully explains the phenomena of”</em> strategy_, “but together they do”_.</p>What is strategy in a business context? That is an even more elusive question than what culture is. I always thought strategy meant market positioning, but my recent academic foray has exposed me to the many definitions of strategy. I list them below, and while some may contradict another, they are in fact all correct. How can that be, you ask? I reckon it is similar to light and sound, which can behave like a wave or a particle under different circumstances (the wave-particle duality). To paraphrase Einstein, the different definitions of strategy present “contradictory pictures of reality; separately neither of them fully explains the phenomena of” strategy_, “but together they do”_.

         This is the point where I defer to much smarter writers to do the explanation. The following definitions are taken from a textbook Managing Change, 6^th Edition by Bernard Burnes wherein he shares five definitions of strategy from Mintzberg’s book The Strategy Process (or see this FT article). I also provide some examples from the real world.

         Strategy as a plan

         According to this view, strategy is some form of consciously intended course of action which is created ahead of events. This can be either a general strategy or a specific one. If specific, it may also constitute a ploy.

         Real-life example

         Microsoft’s deliberate plan to repackage .Net from the ground-up as a cross-platform runtime, and especially re-architecting ASP .Net Core to follow de-facto web development standards, is an example where they are purposefully staking a claim in what they see as the future of software – one where Windows is no longer the dominant OS. I previously shared my negative experience with ASP .Net Core before I realised how much of it has changed.

         Strategy as a ploy

         This is where strategy is a manoeuvre to outwit an opponent. An example of this is when a firm threatens to lower its prices substantially to deter new entrants into its market. It is the threat to lower prices that is the consciously intended course of action, and not any actual plan to do so.

         Real-life example

         It is hard to find a real-life example, since we as observers have no way of telling if a strategic move is merely a ploy. I will try to offer one in the form of Netflix recently announcing their intention to spend US$5 billion in 2016 to produce original content. Why did they have to announce it? They could have built a marketing campaign around how Netflix has more original content than their competitors, but instead they touted that extravagant figure up-front. While I believe they will eventually spend close to that, it looks more like a ploy to rattle up the competition and lock customers in. I’m a Netflix viewer, and I for one am excited to stick around to see what $5,000,000,000 of original content gets me.

         Strategy as a pattern

         This is where we observe, after the event, that an organisation has acted in a consistent manner over time, i.e. whether consciously or not, the organisation exhibits a consistent pattern of behaviour. We can say from this that an organisation has pursued a particular strategy. This may not be the strategy it intended to pursue, but it is the one that has emerged from the action of the organisation. Therefore, though the organisation’s realised strategy could be the product of a conscious and deliberate plan, this is often not the case.

         Real-life example

         This is termed as “emergent” strategy, whereby a pattern of behaviour defines a strategy when we look back at it. I propose that Blackberry (remember them?) fits this definition. When their plans for world domination were halted by Apple iOS and Google Android, a pattern emerged from their efforts to maintain relevance in the marketplace. This started with a major overhaul in Blackberry 10 to prioritise touch screen inputs, and when that didn’t work, acceded to using Android for their latest devices starting with the Priv. Blackberry CEO John Chen responded to the Android adoption by saying, “…We could keep the pride and die hungry or we can eat well and not so proud, maybe. So I chose to eat well. …” Hence, I doubt the decision to go on Android was done deliberately, but one that emerged through its efforts to keep itself sustainable.

         Strategy as a position

         From this perspective, strategy is about positioning the organisation in order to achieve or maintain a sustainable competitive advantage. Mintzberg et al argue that most organisations try to avoid head-on competition. What they seek to achieve is a position where their competitors cannot or will not challenge them. In this sense, strategy is also seen as a game: groups of players circling each other, each trying to gain the high ground.

         Real-life example

         Apple’s smartphones, from day one, have positioned itself as a premium product. This has helped it rise above the tide of competitors by setting a healthy profit margin (estimated 65%) on each phone. With the exception of the iPhone 5c to help enter emerging markets, Apple manages to brand itself as worth those extra dollars. Chief rival Samsung have long taken note of this working strategy and is having the same success with its S-series phones.

         Strategy as perspective

         This definition sees strategy as a somewhat abstract concept that exists primarily in people’s minds. For members of an organisation, the actual details of its strategy, as such, are irrelevant. What is important is that everyone in the organisation shares a common view of its purpose and direction which, whether people are aware of it or not, informs and guides decision-making and actions. Consequently, without the need for detailed plans, the organisation, through a shared understanding, pursues a consistent strategy or purpose.

         Hypothetical example

         Strategy as perspective basically refers to a culture-driven strategy. Without having an explicit strategy plan/ploy/position, a company’s actions can still be cohesive when it is bound by the internal culture. For example, the hypothetical Acme Inc.’s culture is one of continuous improvement. They also love Agile Scrum. From this emerges a strategy of monthly software releases that Acme uses to keep their customers engaged and happy.

         Footnote

         It is important to note that this is only one person’s definitions. Indeed, there are probably as many definitions of strategy as there are companies in the world, so take this as a starting point to formulate your own thoughts on what strategy is.

         Next week: How is strategy formulated?

         ]]>https://www.coderfrontline.com/cutting-edge-technology-cuts/Sun, 24 Apr 2016 04:51:09 +1200https://www.coderfrontline.com/cutting-edge-technology-cuts/<p>I bring you a cautionary tale this week about the dangers of using cutting-edge technology and how it can cut you. Like many programmers I get excited with the prospect of using new technology, frameworks, or languages – especially for commercial uses. It’s one thing to try stuff out on the weekend and build tutorial projects, but it’s another ball game to actually build something someone would buy. So I rubbed my hands with glee when the opportunity arose to redesign a web app that was written in ASP .Net MVC 3.</p>I bring you a cautionary tale this week about the dangers of using cutting-edge technology and how it can cut you. Like many programmers I get excited with the prospect of using new technology, frameworks, or languages – especially for commercial uses. It’s one thing to try stuff out on the weekend and build tutorial projects, but it’s another ball game to actually build something someone would buy. So I rubbed my hands with glee when the opportunity arose to redesign a web app that was written in ASP .Net MVC 3.

         While there are some firms that like to upgrade their technology with every major release, they are the exception from the norm. For the majority, technology is merely the vehicle to deliver business value to customers, and there is no reason to change vehicles while the current one is still working fine. That’s why there are still a lot of production software running on COBOL or VB6.

         The web app product that I’ve been working on (let’s call it Firewatch – no relation to the interesting game by Campo Santo) was created about 5 years ago on ASP .Net MVC 3. Cutting-edge technology at that time, but in the intervening years there’s been a bit of an explosion in the web development world with the rise of mature frameworks like Bootstrap, Node JS, and AngularJS. They have redefined how most web apps are developed these days, and Microsoft hasn’t been quiet either. They introduced Web API to support creating RESTful services and the upcoming ASP .Net Core further moves the framework towards being cross-platform and use de-facto web standards.

         In late 2015 I was asked to look into redesigning the Firewatch frontend and saw it as a chance to move things up a notch. I looked around and read about the upcoming ASP .Net 5 (codename vNext) and it looked really promising. According to the product roadmap at the time, they were releasing RC1 in November followed by RTM in the first quarter of 2016. I thought “Hmm that fits the project schedule just fine. I can start with RC1 and transition onto the RTM when it’s released.”

         I did an impassioned presentation to my colleagues on why going onto the cutting-edge technology of ASP .Net 5 was the right choice and got them quite excited. The first couple of weeks building up the basic views went fine, but then I hit a major roadblock – referencing projects built on classic .Net was a real hassle. There were some real oddities in how it tries to wrap existing projects into NuGet packages, and I wasn’t the only one having issues with wrapping either. That thread was created May 2015 and is still getting occasional posts from frustrated developers 11 months later. Even when I managed to do the workaround on my machine, the build machine did not recognise the wrapped packages.

         The last straw that broke the camel (i.e. me) was the announcement that they’re renaming ASP .Net 5 to ASP .Net Core. It finally dawned on me that vNext was not just a major step up, it’s a major step to the side. I had picked ASP .Net 5 on the basis that it is the next major release, as its name would suggest. This announcement finally acknowledges that this change is foundational and developers should not assume their prior knowledge is transferable to the new wild west of .Net Core.

         I threw my hands up and backtracked on my recommendations. I proposed moving down to ASP .Net 4.5.1 with MVC 5 and Web API 2 while Microsoft ironed out the kinks. Indeed, as I write this, the roadmap has been updated to have an RC2 with a TBD delivery date. The only issue is once Firewatch gets all its needs met by the existing framework, there would be little reason to do a major architectural update just to go onto .Net Core.

         The lesson I learned is: cutting-edge technology might be cool, but be prepared to bleed.

         Reminders to self:

         • Don’t trust product roadmaps even from established vendors like Microsoft.
         • When evaluating any technology, consciously seek out existing issues and what many developers constantly complain about. GitHub issues page is a fantastic resource.
         • Rapidly prototype a test project containing unique idiosyncrasies of my project and not just stick within the sample projects playground which always works brilliantly.

         Photo credit: Fernando Reyes Palencia via Visualhunt.com / CC BY-SA

         ]]>https://www.coderfrontline.com/a-theory-on-success-how-to-fail-at-almost-everything-and-still-win-big/Sun, 17 Apr 2016 04:52:27 +1200https://www.coderfrontline.com/a-theory-on-success-how-to-fail-at-almost-everything-and-still-win-big/<p><a href="http://amzn.to/1Qf49Xg">How to Fail at Almost Everything and Still Win Big: Kind of the Story of My Life</a> is the title of an excellent book about success (or lack thereof!) by <a href="http://blog.dilbert.com/">Scott Adams</a>, <a href="http://www.dilbert.com/">Dilbert</a> creator and frequent writer on his personal blog. I’ve been an avid reader of his for years, and have read his non-Dilbert fiction books (<a href="http://amzn.to/1Qf4lWq">God’s Debris</a> and <a href="http://amzn.to/1SSEq8P">The Religion War</a>) as well. What I enjoy most about Scott’s writing style is the concise manner he puts his points across. It’s an important skill to have when trying to make readers laugh in 3 comic panels, and he puts it to good use in his writing. The following is a brief overview of the key points I took away from his book.</p>How to Fail at Almost Everything and Still Win Big: Kind of the Story of My Life is the title of an excellent book about success (or lack thereof!) by Scott Adams, Dilbert creator and frequent writer on his personal blog. I’ve been an avid reader of his for years, and have read his non-Dilbert fiction books (God’s Debris and The Religion War) as well. What I enjoy most about Scott’s writing style is the concise manner he puts his points across. It’s an important skill to have when trying to make readers laugh in 3 comic panels, and he puts it to good use in his writing. The following is a brief overview of the key points I took away from his book.

         Scott put together an excellent SlideShare presentation – “Passion is Overrated, and Goals are for Losers” which I would encourage you to check out before reading my thoughts below. Keep in mind that the slides are only an excerpt of a much larger variety of topics in the book.

         Passion

         I was often told that following my passion is the path to success. I have always acknowledged the joys of doing something you’re passionate about – but it also made me uneasy. For example, I loved video games but I was sure I couldn’t make a steady living out of it. Scott helped illuminate the passion fallacy. It is success that breeds passion, and not the other way round.

         He instead proposes that personal energy is the fuel that leads to success. It makes simple sense when I think about it. There are times when I am super passionate about my work, but there are days when I would rather stay in bed. Instead of focusing on my lack of passion during tough times, I choose to focus on ways to increase my personal energy. This might involve taking a short weekend trip, or plan office social events, or the simplest – catch up on sleep. I find that simple actions can increase my own energy, which helps me perform better at work that leads to increased passion when I successfully complete it.

         If personal energy is the fuel, what is the vehicle to success?

         Systems

         Scott asserts that goals are only useful for narrow purposes, whereas the world today is increasingly complex and fast-paced. This really resonated with my own experience. Back in university I would create goals every semester based on the SMART guideline, and the top one was always to score the best possible grade. Lo and behold – it worked and I scored A’s for all courses, bar one.

         I was fully convinced about the power of goal statements, but I have not been able to replicate goal-setting in my working life. Goals worked in school because courses were known ahead of time and there were fixed evaluation standards. Real life is just a tad messier, I’m afraid! How does one create a Specific (the S in SMART) goal when the goalposts keep shifting?

         Instead of goals, Scott recommends the use of systems, which are basically patterns of behaviours that inevitably lead to positive outcomes. Wait a minute – patterns of behaviours? That sounds like culture! Some examples of systems vs goals that Scott uses are:

         • Goal: Wanting to lose 10 pounds.
         • System: Learning how to eat right.

         A goal makes the person feel like a failure until it is attained, after which the cycle restarts. It also requires willpower, which humans have a limited amount of. A system, on the other hand, empowers that person to make good food choices without needing willpower.

         I interpret it as modifying our personal culture to create habits that will improve the odds of success. This is still a work in progress, but some of the things I have been doing are studying towards a Graduate Diploma in Strategic Management, and writing for this blog. I wouldn’t be able to tell you what my goals are for them. In other words, I have not given myself a success/failure dichotomy. Instead, they are part of my system to improve my own skills in critical thinking, business-domain knowledge, and writing. These little skills all help, I believe, to move me towards ‘success’. Even if I don’t know what success looks like yet!

         A quote on success

         I will end this post with a quote that Scott shared in the book. I agree with him that this simple sentence contains many pearls of wisdom:

         If you want success, figure out the price, then pay it.

         Go check the book out – the paperback is the cost of a lunch. A lunch will sustain you for 6 hours, but this book may sustain you for life.

         ]]>https://www.coderfrontline.com/why-care-about-culture/Sun, 10 Apr 2016 07:43:23 +1200https://www.coderfrontline.com/why-care-about-culture/<p>Over the last 3 posts I have <a href="https://www.coderfrontline.com/culture-re-introduction/">re-introduced culture</a>, <a href="https://www.coderfrontline.com/elements-culture-onion/">explained it as an onion</a>, and <a href="https://www.coderfrontline.com/cultural-web/">explored the cultural web</a>. It’s now crunch time – why care about culture at all? Culture is dynamic and monolithic, made up of deeply-held assumptions and embedded in corporate DNA. Many authors have tried to discredit the idea of cultural change as a strategic move. They recommend tailoring strategies and tactics to fit the existing culture instead.</p> <p>So, why care about culture? I will skip the textbook answers this time and share my personal view. I care about culture because it affects how well I can do my job.</p>Over the last 3 posts I have re-introduced culture, explained it as an onion, and explored the cultural web. It’s now crunch time – why care about culture at all? Culture is dynamic and monolithic, made up of deeply-held assumptions and embedded in corporate DNA. Many authors have tried to discredit the idea of cultural change as a strategic move. They recommend tailoring strategies and tactics to fit the existing culture instead.

         So, why care about culture? I will skip the textbook answers this time and share my personal view. I care about culture because it affects how well I can do my job.

         Keep in mind that culture is not something that only large organisations have. Each and every one of us has an individual culture that is shaped by our life experience and environment. Hence, we bring our own cultural values to the organisation we work for. Two things can happen between your personal culture and organisation culture: either they mostly match, or they mostly don’t.

         If they match – great! But what if it doesn’t? Then one’s options get murkier. I try to avoid getting into this situation by researching the culture of the company I’m considering joining. I can look through their website, the tone of their public communications, how their office is laid out, and how they conduct their interviews. This helps me flesh out a cultural web analysis. Granted, I will never be able to get a complete picture but I now have better tools (and so do you!) besides the generic interview question: “So… what’s the culture like?”

         I then ask myself, “Can I fit the culture of this place?” There will never be a perfect fit, so the real question is more like, “Can I adapt to the culture of this place?” For example, trust is an important ingredient for me to work at my peak, and so I don’t think I’ll do well in a place where I am required to punch in/out and do minute-level tracking of my work. I would personally consider that a form of micro-management and it wouldn’t fit my way of working. I very much prefer to be entrusted with a task and I’ll deliver a quality result in the allocated time.

         On the other side of the interview table, it also helps to understand that candidates bring their culture with them and so we need to evaluate if their culture will fit the role being hired for. My opinion is that skills and qualifications are a small part of the interview process. Knowledge and skills can be learnt, but their personal culture is mostly fixed. Some attempt to evaluate this via psychometric testing. However, professional opinions of its effectiveness vary, and I do not yet know enough to form my opinion around it.

         In summary, yes, you really should care about culture if only for the sake of making sure you’re with the right company. That is what I found most useful about understanding culture. There are bigger questions left to answer - “How can I meld organisational culture to my own?” is one that comes to mind. We’ll leave those for now and come back to the topic of culture at a later time.

         ]]>https://www.coderfrontline.com/cultural-web/Sun, 03 Apr 2016 02:35:26 +1200https://www.coderfrontline.com/cultural-web/<p>A Cultural Web Analysis is another useful tool that helps tease out the constituent parts of an organisation’s culture. It builds upon the <a href="https://www.coderfrontline.com/elements-culture-onion/">Onion Model of Culture mentioned previously</a>, but has more concrete classifications that I found helpful. The Cultural Web was introduced by Gerry Johnson and Kevan Scholes, who were also writers of the excellent Exploring Strategy textbook I used for my Strategic Management course.</p> <p>Once again we will apply it on the fictional Acme Inc. software development team so you can see how elements of the Onion Model translate (and get expanded) by the Cultural Web.</p>A Cultural Web Analysis is another useful tool that helps tease out the constituent parts of an organisation’s culture. It builds upon the Onion Model of Culture mentioned previously, but has more concrete classifications that I found helpful. The Cultural Web was introduced by Gerry Johnson and Kevan Scholes, who were also writers of the excellent Exploring Strategy textbook I used for my Strategic Management course.

         Once again we will apply it on the fictional Acme Inc. software development team so you can see how elements of the Onion Model translate (and get expanded) by the Cultural Web.

         The Cultural Web consists of 6 elements that, taken together, define the “paradigm” of the organisation. Simply put, they are the core assumptions that people in the organisation take for granted. This is the hardest to analyse regardless of your membership status with the organisation – members find it hard to define things they do habitually, and non-members are not privy to the inner-goings that will reveal the paradigm.

         

         The Cultural Web Analysis goes some way to propose a structured approach in identifying the “behavioural, physical, and symbolic manifestations of a culture” (all quotes in this post are from Exploring Strategy, 10^th edition).

         • Rituals and routines: Rituals are special events that emphasise important aspects of the culture, while routines are “the way we do things around here on a day-to-day basis”.
           • Acme: A yearly ritual for Acme developers is to conduct an in-house code retreat that gives the developers a chance to try different development techniques and reinforce the power of pair programming and unit testing. This is largely due to test-driven development being a key routine that they practice everyday.
           • Maps to Rituals and Practices in the Onion Model.
         • Stories: They are tales told between themselves, outsiders, and new members, in order to explain why things are done a certain way. They highlight the “successes, disasters, heroes, villains, and mavericks” in the organisation’s past.
           • Acme: The tale of how Vanushka saved the product launch is one that is often brought up when explaining why Acme does aggressive test-driven development. It is a story containing heroes, successes, and disasters.
           • Maps to Heroes in the Onion Model.
         • Symbols: “Objects, events, acts or people” that represent an idea larger than their functional purpose. For example, company cars serve a functional purpose but they also symbolise status and hierarchy for those who own one.
           • Acme: Developers have a junior, intermediate, and senior ranks, which symbolise seniority and the influence they have on product decisions. In other words, the functional purpose of the job rank is to denote the experience of a developer, but it also confers power beyond its intended function.
           • Maps to Symbols in the Onion Model.
         • Power: Refers to the power structures in the organisation. Power is the “ability to persuade, induce or coerce others into following certain courses of action”. The book authors noted that “the most powerful individuals… are likely to be closely associated with… the long-established ways of doing things”.
           • Acme: The job titles mentioned above are certainly a power structure. “Heroes” like Vanushka are also conferred power in influencing key architectural decisions, thanks to the stories that fuel his reputation.
           • Maps to Symbols in the Onion Model.
         • Organisational Structures: The “roles, responsibilities, and reporting relationships in organisations”. This is simply an organisational chart, but the key point is to look into why it is structured as such because it will reveal the power structures or other symbols.
           • Acme: The development team is actually divided into 2 reporting groups, one for Software Architects, and another for Software Developers. The architects act as consultants, and the developers make the final decision on the best architecture for their needs. From this we can deduce that the power of architects is limited to the advisory stage, unlike most organisations where architects have veto-like power.
           • Maps to Symbols in the Onion Model.
         • Control Systems: They are the “formal and informal ways of monitoring and supporting people… and tend to emphasise what is seen to be important in the organisation”. A great example given in the textbook is about how public service organisations tend to emphasise how public moneys are used rather than the level of service provided, and this is reflected in the control mechanisms used.
           • Acme: Peer code reviews are a control system used to ensure that Acme’s development practices are adhered to, especially the presence of unit tests. Besides that, 360-degree reviews form a small part of the annual performance evaluation.
           • Maps to Practices in the Onion Model.

         All of those six elements inform, and are informed by, the Paradigm. Mapped to the Values core of the Onion Model, they are the commonly held assumptions in the organisation. They tend to be very basic rather than specific. Looking back at the Cultural Web Analysis for Acme Inc., one might surmise that a paradigm of the development team is the importance of technical excellence through their aggressive unit testing practice and stories told. However, from that we can note a lack of focus on customer satisfaction, i.e. Acme might create the most perfect, bug-free software ever written, but does it actually meet the customer’s needs?

         Now that you have a good idea of what a Cultural Web Analysis entails, I urge you to take a cursory look at your organisation, team, family, and yes, even yourself! Culture exists on the personal level all the way to the largest organisations, and being able to analyse it is the first step in planning for success. It shouldn’t take more than 30 minutes to do a first draft that fleshes out the main parts.

         I will conclude this introductory series on culture next week by answering the question I previously posed – “Why should I care?”

         ]]>https://www.coderfrontline.com/posting-schedule/Sun, 27 Mar 2016 22:36:42 +1200https://www.coderfrontline.com/posting-schedule/The posting schedule for this blog is about once a week. I set aside about 4 hours a week to work on the blog, and this week I&rsquo;m using that time to approve a new logo through Mike on Fiverr and update some site elements based on the new graphics. My posts on culture resume next week.The posting schedule for this blog is about once a week. I set aside about 4 hours a week to work on the blog, and this week I’m using that time to approve a new logo through Mike on Fiverr and update some site elements based on the new graphics.

         My posts on culture resume next week.

         ]]>https://www.coderfrontline.com/elements-of-the-culture-onion/Sat, 19 Mar 2016 22:43:16 +1200https://www.coderfrontline.com/elements-of-the-culture-onion/<p>My last post gave a <a href="https://www.coderfrontline.com/culture-re-introduction/">brief explanation of what culture is</a>, the main takeaway point being that culture is all around us on different levels. The next logical question is, “<a href="https://www.coderfrontline.com/why-care-about-culture/">Why should I care?</a>” I&rsquo;ll answer that in the next few weeks because we need to take a short detour – specifically, how would one analyse and assess the culture of a given group? The answer may lie in the culture onion.</p> <p>Although cultures can be difficult to compartmentalise, try we must, and much smarter people before us have offered some suggestions. Let&rsquo;s check them out and apply it on a fictional group – the Acme Inc. software development team._</p> <p>_</p>My last post gave a brief explanation of what culture is, the main takeaway point being that culture is all around us on different levels. The next logical question is, “Why should I care?” I’ll answer that in the next few weeks because we need to take a short detour – specifically, how would one analyse and assess the culture of a given group? The answer may lie in the culture onion.

         Although cultures can be difficult to compartmentalise, try we must, and much smarter people before us have offered some suggestions. Let’s check them out and apply it on a fictional group – the Acme Inc. software development team._

         _

         

         (Source: Unfold Conflicts)

         It’s helpful here to think of culture as an onion. The outermost layer is the Symbols layer. These are the visible signs of culture that even non-members can see. A good example is job titles, like how Acme’s developers are segmented into junior, intermediate, and senior software engineers.

         Peel back the symbols layer and you might find the Heroes layer. These are the people that embody the whole culture, and is usually an aspirational figure. For example, one of Acme’s heroes is Vanushka ‘the Brave’, who worked all night that one time to get their Docker installation on Azure running again. Such heroics are praised and newcomers are told of how Vanushka saved the company’s reputation before the big launch.

         Rituals come after the Heroes layer, and as the name suggests, it represents the habitual activities that occur without much thought (or are taken for granted). In Acme, developers mark the end of a sprint by having Friday afternoon pizza and drinks. It’s not a formalized procedure or mandated management practice – it is accepted that it “just happens”.

         Cutting across the first 3 layers of the onion are Practices. They represent the activities that are performed regularly and are influenced by the Symbols, Heroes, and Rituals. For instance, Acme practices test-first development (ritual) and any developer who sneaks code in without a suitable test would get a swift rebuke from a Senior Engineer (symbol). After all, Vanushka is the aspirational figure (hero) that other developers look up to and it was unit tests that helped Vanushka troubleshoot the critical issue.

         At the core, which all the previous layers inform and derive from, are the Values (also known as Paradigms). They represent the deeply held beliefs within the culture and are the hardest to identify, especially from the outside. They are usually quite basic in nature, but absolutely crucial in that it supports the rest of the culture. One of Acme’s paradigms is the importance of following process, as when coders who miss a unit test are called out. Another attribute valued by Acme is the dedication to getting work done at all costs, as when Vanushka spent all night fixing a critical issue.

         The double-edged sword of Values is that they are ingrained and are difficult (some would say impossible) to change. Let’s say the unspoken practice of working late to fix production defects is seriously damaging developers’ work-life balance. Is it a simple matter of outlawing work after 8pm? The issue here is that the “get work done at all costs” ethic is a core value of Acme, and any person who attempts to change it will have to confront the cultural rubber band. This is a topic I will come to at a later stage when I write about culture change efforts.

         The key point of my post is: culture is comprised of many elements and some are more ingrained than others.

         Next week, I will present a model of analyzing culture that I personally found helpful to identify the different layers of the culture onion.

         ]]>https://www.coderfrontline.com/culture-a-re-introduction/Sun, 13 Mar 2016 01:38:15 +1200https://www.coderfrontline.com/culture-a-re-introduction/<p>‘Culture’ as a term is a loaded word. Experts from different fields have their own definitions, which makes it that much harder to comprehend. It is also understandable when people react negatively as it gets bandied about. It’s used as a scapegoat – “Our product launch failed because we didn’t factor in the culture”, and often elicits eye-rolling – “We’ll boost company morale with our culture change programme!” It’s also a common phrase in job ads – “Come join us, we’ve got a great culture!”</p> <p>Are any of them valid statements? I think it’s time to strip culture back down to basics, in order to understand how it affects us.</p>‘Culture’ as a term is a loaded word. Experts from different fields have their own definitions, which makes it that much harder to comprehend. It is also understandable when people react negatively as it gets bandied about. It’s used as a scapegoat – “Our product launch failed because we didn’t factor in the culture”, and often elicits eye-rolling – “We’ll boost company morale with our culture change programme!” It’s also a common phrase in job ads – “Come join us, we’ve got a great culture!”

         Are any of them valid statements? I think it’s time to strip culture back down to basics, in order to understand how it affects us.

         Mind you, this is a blog post not a thesis, so we won’t be able to comprehend every facet of culture but we can at least cover some ground. The best analogy I’ve come across likens culture to the air we breathe. It’s all around us, but we don’t notice it until it’s gone. It’s also surprisingly hard to define. Yes, we can define the air around us as a mixture of hydrogen, nitrogen, oxygen, and other gases. But that will ignore its life-sustaining properties, the nuances in different smells (pleasant AND unpleasant!), and what it means to us. The same is true with any definition of culture – it’s at best incomplete and you should keep that in mind with the next few blog posts.

         At its core, culture is “the way we do things”. ‘We’ is a very fluid term that can refer to any grouping of people that have a shared identity. The most common example is the idea of a national culture, that people within a country act or behave a certain way. No discussion of national culture would be complete without mentioning the comprehensive work of Geert Hofstede, who profiled national cultures along a range of cultural variables. Check some of the results out on the Hofstede Centre to see analyses on national cultures.

         It’s an utterly convenient set of results, but I need to point out some shortcomings in his work. First, his initial results are derived from studying employee values in IBM in their international subsidiaries. This is hardly representative although subsequent studies have expanded their respondents to include “commercial airline pilots and students”, “civil service managers”, and “‘up-market’ consumers” (Hofstede Centre). Sampling bias, anyone?

         Secondly, some countries are so big, i.e. India and China, that there will undoubtedly be geographic variations within the results. Hence, Dr. Hofstede’s results are a mere launching pad for further analyses on culture. For more information on this, check out the GLOBE study and Trompenaars’ ten-year study of management.

         Most people simply stop at national culture, which would be a disservice. The fact is culture binds people in groupings beyond geographical boundaries. Logical groups such as organisations will have its own culture, and if we expand our magnification level, we’ll note that departments might have its own sub-culture too. Look closer again and you might pick out individual teams as having their own culture quirks. And that is the messy reality when we try to study culture and how it affects everything from strategy implementation to hiring an employee.

         And how exactly does one study culture? My next post will detail some basic elements of culture and a simple analytical tool that might help uncover the nuances of culture.

         ]]>https://www.coderfrontline.com/yet-another-tech-blog/Sun, 06 Mar 2016 15:00:53 +1200https://www.coderfrontline.com/yet-another-tech-blog/<p>Oh no – not another one! Yes, I’ll be the first to acknowledge that there are probably enough programming and tech blogs out there. I’m doing this because I believe I have a unique perspective to share that you’ll be interested in. Coder on the Frontline is a blog focused around the realities of commercial software development today – think missed deadlines, incomplete requirements, Agile fanatics, and that latest buzzword ‘DevOps’. I can see you nodding your head already.</p>Oh no – not another one! Yes, I’ll be the first to acknowledge that there are probably enough programming and tech blogs out there. I’m doing this because I believe I have a unique perspective to share that you’ll be interested in. Coder on the Frontline is a blog focused around the realities of commercial software development today – think missed deadlines, incomplete requirements, Agile fanatics, and that latest buzzword ‘DevOps’. I can see you nodding your head already.

         I will also be sharing my thoughts on the world surrounding software development. We don’t work in a vacuum – there’s testing, customer support, sales, management – the list goes on. They’re happening around us at the same time, and the more we know about them, the better we can do our jobs. I aim to build that bridge between programmers and everyone else.

         A little backstory: I finished my degree in Software Engineering in 2006, and went straight to work for an R&D team in an American multinational specializing in test and measurement. I enjoyed the benefits of working for a large company – subsidized lunches, free GP visits, and free t-shirts with the latest department initiatives emblazoned across it. On the other hand, I felt increasingly constrained on multiple levels. I was a human resource – more resource, not so much human. I was merely a number, literally, as all company resources had to be accessed using our employee ID.

         I hatched an escape plan, and in 2011 I made my way to New Zealand armed with 3 bags and a work visa. I had never travelled outside Asia, and only 9 months to find permanent work or leave.  A risky proposition, but I was prepared to fail and head home. Fortune favours the bold (and the right economic climate), because I was lucky to find a coding job in Auckland after 8 weeks. That’s where I’ve worked at for the past 5 years, and what a difference it was. It’s a small family-run firm with a niche product and market. At under 30 people in the whole place, there are no employee IDs and we developers have to do more than just cut code. I finally discovered the human portion of ‘human resource’.

         I had grown enough that I began wondering “What’s next?” and that eventually led me to study towards a Graduate Diploma in Strategic Management. As of this writing I’m 8 months from completing my studies with the Open Polytechnic, and the things I’ve learned have spurred me to create this blog. I see my daily work through fresh lenses now, and it is my hope to empower you to do the same.

         I am by no means an expert (Tip #1: be wary of anyone calling themselves an expert), so I invite you to join the conversation and learn from each other. I will reflect and share my thoughts on a variety of issues – from strategy to coding reviews to politics (yes, even politics). It may get a bit ugly, but that’s life for coders on the frontline!

         ]]>