Author: MarkC

Day One in Vietnam.

We arrived in Ho Chi Minh City at around midnight, and it was a lot like walking onto the set of some sixties war movie. The border security look like they are in slightly overdone third world bad guy costumes, complete with the communist style army caps. We spent half an hour or so walking up and down looking for our airport transfer, who had clearly opted for bed instead of a very late night pickup.

Once we gave up on our transfer we tried in vain to find a sober taxi driver. I picked one who seemed sober, or at least could pass for vertically capable. He then grabbed one of our cases and took off into the parking lot. We chased him down and caught him at a people mover, and then we negotiated a fare. A second person then came to renegotiate and round up, and insisted “tip tip tip”. We then did a circle round the parking lot, and they swopped drivers. again. The new one seemed half sober so we got our hopes up. He proceeded to grab my wallet and audit it for me, just to make sure I didn’t have anything in there he would like to relive me of. After this display of kindness we felt we had found the man to take us to our hotel… but after another circle round the parking lot they swopped back to the first guy.

We finally left the parking lot, after the first taxi driver had told us “not happy” a few times. My wallet was the equivalent of twenty dollars lighter, and we drove four minutes down the road to our hotel.

Vietnam is a funny place, and it’s 2am – we haven’t even started yet.

In May I presented at the Web World Forum, a part of World Forum Disrupt Sydney 2017.  I spoke about how we were trying to shift our culture in digital tech and product delivery at Domain to be even more focused on business outcomes.   
 

Link to the video of the full talk is here and the slides from my talk at the conference are ‪here

A fortnight ago, Domain supported and participated in a hackathon organised by Vibewire – #hack4homelessness.  Vibewire are a coworking space based close to Domain’s head office.  Vibewire focus on equipping young people with various business skills – and from what we’ve sen this seems to include a social conscience.  Vibewire focus on the youth, and homelessness disproportionately affects the youth so there’s a natural synergy there.  At Domain we want to see everyone in a home they are happy to live in, and so we found real synergy with #hack4homelessness too.

When we got together to discuss how we might be able to help, one of the first ideas that came up was the sharing of our Public API with all hack teams.  We launched our API recently and we’ve already signed up hundreds of users so we knew it would work well enough for the hackathon users.  We also framed a challenge for the hackers to tackle – how do we try help supply of housing meet demand.  We saw some very clever ideas emerge including requests for features our API’s don’t yet support.

One of the most inspiring things about the hackathon was seeing so many young people giving so much of their time and energy to work on problems that they do not stand to gain from solving.  The energy in the hackathon was palpable and the participants worked with amazing zest.  The pitch sessions at the end were fantastic as the participants spoke us through their lean canvases, occasionally showing that they’d learned a few new tricks out of the process themselves.

Most touchingly, the organisers had speakers talking about homelessness at the kickoff – but these were not merely presentations of statistics and charts.  Participants got to engage with people who work directly with the homeless, and even with people who have first-hand experience of homelessness.  This made the experience so much more palpable and real.

Domain were proud to support this amazing initiative – alongside several other supporters.  We look forward to supporting #hack4homelessness again in the future, and a shout-out to the Domain team members who gave up their weekends to support!

I presented a talk at the recent Ignite Sydney event that was run recently. This event had a specific focus on Digital and tech. It’s worth checking out all the speakers. In coming up with a topic, I was having some fun with the industry’s abuse of the concept / word “disruption”. I spoke about changing an old, established, mature business to try deal with the shakes and shudders of being disrupted. The real point was about trying to create a change-oriented culture. My talk is on YouTube here

We’ve been playing with Arduinos for the last few weeks.  Yesterday I bought a Freetronics Dot Matrix Display (DMD) from Jaycar for $30 or so, and I’ve cobbled together a couple of scripts to drive some RSS content to it.  It works 🙂

I have a SainSmart Mega 2560, but there’s no reason this shouldn’t work with any Uno compatible. Note – this DMD doesn’t work with the Mega unless you overwrite a couple of files (Thanks @TheRevva for sharing)

Before starting, two ruby gems are needed – SerialPort and FeedJira -thanks @johndagistino [protected] for the steer.  It’s also worth spending time going through the code samples Freetronics have made available on github – linked at the bottom their product page

Note – I still have a problem with serial comms in that it doesn’t work unless I have the Serial Monitor open.

gem install serialport

gem install feedzilla

This is the ruby test script that I’ve used to grab two rss feeds, and pass the headlines in one at a time into to Arduino over the serial port.

require "serialport"
require "feedjira"

def showfeed(feedurl)
	#params for serial port
	port_str = "/dev/tty.usbmodem621"  #NB port may be different for you, copy this from port selected in Arduino IDE 
	baud_rate = 9600
	data_bits = 8
	stop_bits = 1
	parity = SerialPort::NONE
	 
	sp = SerialPort.new(port_str, baud_rate, data_bits, stop_bits, parity)
	feed = Feedjira::Feed.fetch_and_parse(feedurl)
	sp.write feed.title
	puts feed.title
	sp.write "   "
	sleep(8)

	feed.entries.each do |entry|
		sp.write entry.title
		puts entry.title
		sp.write "   "
		sleep(8)
	end
end
showfeed('http://feeds.smh.com.au/rssheadlines/top.xml')
showfeed('http://www.theverge.com/rss/frontpage')

And lastly, the Arduino sketch to drive the rss feed onto the display:

// dmd-rss.ino

#include "SPI.h"      
#include "DMD.h" 
#include "TimerOne.h"
#include "Arial_black_16.h"<arial_black_16.h> 
// you can remove the fonts if unused
#include "SystemFont5x7.h"

#define DISPLAYS_ACROSS 1   
#define DISPLAYS_DOWN 1       
/* change these values if you have more than one DMD connected */
DMD dmd(DISPLAYS_ACROSS,DISPLAYS_DOWN);

void ScanDMD()
{ 
  dmd.scanDisplayBySPI();
}

void drawText(String dispString, int scrollspeed) 
{
  dmd.clearScreen( true );
  dmd.selectFont( SystemFont5x7 );
  char newString[256];
  int sLength = dispString.length();
  dispString.toCharArray( newString, sLength+1 );
  dmd.drawMarquee(newString,sLength,( 32*DISPLAYS_ACROSS )-1 , 0 );
  long start=millis();
  long timer=start;
  long timer2=start;
  boolean ret=false;
  while(!ret){
    if ( ( timer+1000-scrollspeed ) < millis() ) {
      ret=dmd.stepMarquee( -1 , 0 );
      timer=millis();
    }
  }
}

void setup()
{
	Serial.begin(9600);
   Timer1.initialize( 5000 );           
/*period in microseconds to call ScanDMD. Anything longer than 5000 (5ms) and you can see flicker.*/

   Timer1.attachInterrupt( ScanDMD );  
/*attach the Timer1 interrupt to ScanDMD which goes to dmd.scanDisplayBySPI()*/

   dmd.clearScreen( true );            
/* true is normal (all pixels off), false is negative (all pixels on) */
}

void loop() {
  
  String content = "";
  char character;

  while(Serial.available()) {
      character = Serial.read();
      content.concat(character);
      Serial.println(content);
  }

  if (content != "") {
  	drawText(content,980);
  	delay(1000);
  	dmd.clearScreen( true);
  	delay(500);
  }
  else {
    delay(500);
	}
	
}

I had a chat with Brett Winterford recently, a journalist writing for IT News, about continuous integration and continuous deployment (article here).  The essence of our discussion was focused on the question “Can legacy enterprise teams move into CI/CD”.  The answer to the question has to be yes, for a couple of reasons.

First and foremost, our competitors can no longer be regarded as the same competitors we had when news was delivered daily in print and technology projects could run for three years (and did!) without seeming unusual – merely “big”.  Our competitors now are globally placed, and can set up a competitive news source about as quickly as you can make an omelette. That’s the benchmark.  If we can’t tweak a feature on one of our sites and test it live inside of 24 hours, we might just be dinosaurs waiting for a meteor.  Most of the newer digital media businesses can do this, and many of our legacy competitors are on this journey as well.  This is why it’s a baseline expectation, not a target.

Secondly, as we move into a world of KPI’s focused on site performance including competitive benchmarking we need to be able to call a slowdown worse than a particular measure a severity one issue, and ask the relevant team to stop their project work and turn their attention to the slowdown until the issue is resolved.  This can’t really work unless we can release the performance fixes and test them continuously – preferably using RUM (Real-user monitoring) and this couples these two objectives.

Third, in a recent restructure my team was expanded and now includes responsibilities from design through to support.  Part of the motivation for this is a desire for faster output.  I’ve had several people dispute this is feasible – on the basis that we are running at capacity already.  I believe we can achieve good results in a couple of ways though.

As we are all in one team now, we can lean out our management processes and push closer to pure agile / Scrum and ship a lot more smaller releases.  This will create a perception of velocity in its own right, but will also gain faster feedback – allowing teams to refine or pivot more quickly, and get to the right outcomes quicker.  Product managers will also be able to do their UAT incrementally instead of waiting for releases, which will lean out the UAT processes.

Lastly, testing as a function will change fundamentally in a CI/CD environment and our testers will be increasingly automation specialists who will work with the project teams to make sure they have tests in place.  This will mean more testing is automated, and done quicker than human hands can do it.