Developer Developer Developer 11
I had a great time at DDD 11 in Reading, U.K. today — there were many great speakers with entertaining talks, and it was also a time for catching up with some old, good friends.
As most of the talks were presented simultaneously in four different rooms, I can only report on a minority of them, but please share your own experiences as well and we can build up a complete report.
The complete schedule is available at http://www.developerdeveloperdeveloper.com/Schedule
The first talk I attended was “Brain Surgery for the autodidact — How I relearned learning” by Graeme Bradbury. It wasn’t until a saw the titles given to both podcasts that I realized how important learning was to me. So this was a talk that strongly appealed.
Graeme also gave a similar version of this talk at CodeNode in London on 18th October and you can watch it in full here. I will include timing information in brackets e.g. (05:00) so that you can skip to the most interesting section for you.
Graeme has been a software engineer for 16 years and is currently working for an F1 team. He grew up reading books and leaned on them for learning. He enjoys spending an hour per day learning, typically by reading a book.
He said three important things for effective learning are:
- Consistency
- Momentum
- Engagement
In this photo, there is a source, but it’s bogus. There’s a similarly named company, but they have a web page saying they did NOT produce this research. It’s based entirely on anecdotal evidence, not any real science. (3:00)
There has been some recent research (October 2016) that shows the difference in retention rates between reading, and practicing by doing, is less than 10%.
There is also some real research behind VARK which stands for Visual, Auditory, Read/Write, Kinesthetics. Graeme said this technique has led to 1.5 to 3% better grades in exams. (06:30)
He spoke about Chess Grandmasters being no better than any average human at recall when the positions were randomized. (11:00)
They use a method called chunking for their amazing recall. In simple terms this is spotting patterns and using that as a mental shortcut. See wikipedia for more.
In 1975 the world record for remembering the number of digits of π was 511. Today, it is 70,000 and that was only because another person was harshly disqualified in his attempt to recite 100,000 digits. This massive improvement is all due to training.
Graeme said laptops are a bad method for taking notes. Handwritten notes work much better.
Self rehearsal is important. Re-reading your notes. 1 day after, 1 month after, and 2 months after. An easy way to do this is to setup your computer to email your notes back to you on set dates in the future. (13:40)
Graeme recommends the book Poor Charlie’s Almanack, by Charles T. Munger, who he describes as a polymath. (15:40)
Perhaps the most important takeaway from this book is how important it is to ignore lower priority work. These tasks only serve as a distraction from your top priority work.
He recommends Haskell over F# for the purposes to efficiently learning functional programming. (17:40)
He also recommended talking out loud to yourself. This is essential for practicing talks — if you just practice in your own head you will sound perfect. Talking out loud is much harder until you are sufficiently practiced.
He spoke about having no decisions to make. Mark Zuckerberg and Barack Obama are two examples of people who wear identical clothes so that they have no decisions to make in the morning. (19:10)
Ego depletion doesn’t exist.
He also explained Habits and the Cue-Routine-Reward loop. I can personally recommend reading “The Power of Habit” by Charles DuHigg if you want to learn more about this. (20:30)
He said it’s important to recognize engagement, but engagement is the opposite of flow and tends to make you feel less happy. (28:32)
Talent is often overrated, but the age when your begin learning matters a lot for some topics.
When it comes to learning the violin, for someone to become renowned as world class by the age of 30, they need to practice for 10,000 hours before they get to the age of 20. (34:48)
The guy with the world record for reciting π practiced for about 3,000 hours. Some people have 10 years experience while others have 1 years experience 10 times: it’s all about deliberate practice. He gave an example of deliberate practice while fixing bugs. (36:30)
Graeme recommends learning at high speed, taking notes while studying. Then look back at your notes and see where you struggled to write good notes.
He recommends SQ3R: Read-Recite Review (32:22)
The role of the teacher is just to let you know when you make a mistake. Experienced developers can often feel that code is wrong even when they are not certain why. (40:50)
Understanding the problem is halfway to solving the problem.
In conclusion, all of the above techniques have helped Graeme to go home at 5:30 pm each day and see his kids. (44:20)
Meanwhile the following other talks were being presented:
“This is Not the Async you are looking for!” by Liam Westley
“Safe At Any Speed” by Ian Cooper
“How to Make Your Bookie Cry” by Gary Short
Craig Philips attended and has reviewed this one.
The second talk I attended was “The Internet: transforming society and shaping the future through chat(bots)” by Galiya Warrier.
Galiya began with a history of chatbots and then moved onto demonstrations. She has written a T-Rex chatbot using the Microsoft Bot Framework.
Meanwhile, the following other talks were going on:
“Microservice Architecture at ASOS” by Ali Kheyrollahi
Craig Philips attended and has reviewed this one.
Ali has published the slides on SlideShare.
“Reactive applications with Akka.Net” by Antony Brown
Slides from last year’s version of Antony’s talk are available on SlideShare.
Also he is putting the final touches on the Manning book
“A Piece of Cake — C# powered cross platform build automation” by Gary Park
The third talk I attended was “Somewhere Over The Windows…” by Mark Rendle. Mark blogs at https://blog.rendle.io/
Mark joked that he decided to do a talk about dropping Windows because he didn’t like being an Microsoft MVP :-)
He said Windows has fallen behind in some areas, for example HTTP/2 which is supported by all the latest browsers but not IIS unless you have Windows Server 2016.
Every 4 years Windows shouts “Hold on, wait for me!” and then moves its tent somewhere near where the competitors are and pitches up there for another 4 years.
Mark said .NET Core holds the key to getting out of this rut, because it allows us to program in C#, the “best general purpose language in the world”, in any operating system we like.
In case you’re confused by all the names, project K, DNX, ASP.NET 5 and ASP.NET Core 1.0 all mean pretty much the same thing.
He said the Kestrel HTTP Server is bloody fast!
He gave a .NET Core hello world demo in Linux, and spoke about Yeoman.io — a good scaffolding package.
He confirmed that ALL web developers need to use Node.JS to some extent now, and said Bower “used to be great”.
IDEs and editors that work on Linux are:
- Visual Studio 2015 Update 3
- JetBrains Rider (EAP)
- Xamarin Studio
- Visual Studio Code
- Atom
- Sublime Text 3
- Vim
- Emacs
He said Emacs is a brilliant operating system, except for the lack of a good text editor ;-)
Mark likes Visual Studio Code the best and says it is about 10 times faster than Atom, despite being based on the same Electron UI Framework.
He made some jokes about all the logging options in the .NET Framework. Logging is first class in .NET Core.
Mark gave an introduction to Docker, and said it is the best reason to use Linux.
Containers are like very small Virtual Machines. They are isolated, and have a layered file system.
We can get Docker for Windows and Mac now.
With .NET Core we use Docker by writing a docker file. We saw a demo of an app running inside a Docker container.
It is only a slight simplification to say that instead of “It works on my machine” syndrome, with Docker we just ship the machine along with the code!
We also saw Docker-compose.yml.
Due to an unexpected error, Mark used the “kill -9” command, but it told him he didn’t have permission. He said the only reason he hadn’t setup an ffs alias was he didn’t have time earlier. So he manually typed in “sudo kill -9”
I learned that kill -9 means “kill with fire”
An important point was that although Kestrel is bloody fast, it’s not a production web server. You’ll want to use Kestrel behind Nginx so that it is secure.
We saw a comparison of IIS and Nginx. Whereas IIS uses the IIS Management Console, this is done with nginx.conf files. We have Reverse Proxy instead of the IIS Integrated Pipeline. Nginx also uses the Lua programming language, whereas IIS has ASP.NET Modules.
Mark recommended https://github.com/jwilder/nginx-proxy
Mark is also writing a new blog post on Let’s Encrypt.
He also introduced ELK: Elasticsearch, Logstash and Kibana. He gave another demo for how to use this, and said you can easily switch to Splunk if you need to. Mark likes the Unix philosophy of doing one thing well.
Craig Philips also attended this one. Click here for his take on it.
Meanwhile the following other talks were going on:
“How to Speed up .NET and SQL Server Web Apps” by Bart Read
“Real World REST and Hands-on Hypermedia” by Dylan Beattie
“Mashing monoliths into manageable modules, with Mediatr” by Alex Brown
And then we had lunch.
But it started to rain and we were invited back in to watch 10 minute Grok talks. The first one was given by Rik Hepworth.
Rik is an Azure MVP. He works for Black Marble and blogs at http://blogs.blackmarble.co.uk/blogs/rhepworth/
Rik gave an introduction to ARM Templates. ARM stands for Azure Resource Manager. The templates are useful for avoiding fights between Ops and Developers.
We saw a demo using a preview version of Azure Resource Explorer. He recommended using the full version of Visual Studio because it has a number of useful Azure Templates.
Next up was Andrew Fryer: a data scientist who works for Microsoft and blogs at https://blogs.technet.microsoft.com/andrew/
This was a Power BI talk. Power BI was originally an end user tool but is now part of Azure. He said having data in the cloud can be safer than having it on the ground.
Then Liam Westley gave the talk “What is the point of Microsoft?”. Liam is a six or seven times Microsoft MVP, works for Huddle and blogs at http://geekswithblogs.net/twickers/Default.aspx
This talk was full of jokes, but there were some important points as well.
Liam said that whereas Apple has commoditised software and sells hardware, Microsoft sells software and have commoditised hardware. Google and Facebook sell you! And Amazon actually sell real stuff! But they also do cloud stuff.
Last but not least was Ben Hall.
This talk introduced https://www.katacoda.com/ which is an interactive learning platform that is available for free.
This looks really good, lots of great stuff on there already so check that out. Ben also blogs at http://blog.benhall.me.uk/
The fourth full length talk that I attended was “Performance is a Feature” by Matt Warren.
Performance is a fascinating topic in my opinion, and this was my favorite talk of them all.
Matt works for CA, who are still better known as Computer Associates despite the name change.
He asked the audience to raise their hand if they had performance requirements. About half did. He asked if those requirements were measured? Are they enforced by tests? Are they repeatedly enforced by tests?
By the time he asked this last question, nobody in the room had their hand up any more, and Matt said that he has found that to be fairly typical.
The title of the talk is borrowed from the Coding Horror article and the talk focused on the .NET CLR.
Usually the biggest performance gains are made on the Front-end, followed by the database and the caching.
Guy Martin once said you need to have “mechanical sympathy” to be a successful racing driver.
There’s a performance blog named after this quote.
Matt gave the following reasons why performance matters:
- Save money
- Save power
- Bad performance == broken (in the opinion of the users)
Google only did some A/B testing and found a 1/2 second delay cased a 20% drop in traffic.
The next question is
What?
Matt boldly stated that averages are bad. He clarified that they are okay if you have a normal distribution.
Hans Rosling has some interesting TED Talks, such as https://www.ted.com/talks/hans_rosling_shows_the_best_stats_you_ve_ever_seen?language=en
Matt explained that a good alternative to averages are histograms. We saw an example where the average response time was 38 milliseconds but the data was spread in two very different areas. Some times were over 100 milliseconds because of caching. That would have been almost impossible to know without the aid of the histogram.
How?
Measure, measure, measure
- Identify bottlenecks
- Verify that the optimisation works
Matt spoke about the Stack Overflow tool http://miniprofiler.com/ and about http://getglimpse.com/
There’s also the https://github.com/opserver/opserver/ monitoring system.
Matt said micro-benchmarks don’t tell the whole story, and we should do profiling first. He also repeatedly warned not to put any “performance fixes” straight into production without proper testing.
If you’ve not see BenchmarkDotNet before see this article from Scott Hanselman:
Matt said PerfView is very underrated and we should use it more often. Although it looks ugly, the information that it provides is great.
% Time in GC is a useful metric, obviously the lower the better.
Matt recommends reading this Sam Saffron article:
Stack Overflow performance lessons were:
- Use static classes
- Don’t be afraid to write your own tools
Matt clarified these points, which should be taken with a pinch of salt! Static classes are generally a bad practice in terms of writing clean, easily testable code. And when the article was written there weren’t as many performance tools available as there are today, so you won’t necessarily need to write your own.
We also saw 3 Roslyn performance lessons based on Dustin Campbell’s Channel 9 TechEd talk from 2013
The full talk is great, but it is over an hour long. This short summary is for maximum performance:
- Avoid boxing
- Don’t use LINQ (use foreach and if statement)
- Use object Pooling
Meanwhile the following other talks were going on:
Azure Service Fabric and the Actor Model: when did we forget Object Orientation? — Joao Pedro Martins
Craig Philips attended and has reviewed this one.
Getting your Splunk on — a developer’s introduction to Splunk — Joel Hammond-Turner
Joel has put up all the slides from his talk.
Web security basics — key lessons from OWASP and your favourite infosec incidents — Robin Minto
The final talk I attended was .NET Core at Scale with Docker Swarm by Elton Stoneman.
If you’re a Pluralsight subscriber, Elton has done some very good courses and I hope to review one or two of them for you in the future.
Coincidentally today was book-ended with talks about π. Elton demonstrated calculating π to 20,000 digits.
He began by explaining .NET Core — it is .NET Evolved, cross-platform, open source and modular.
To introduce .NET Core gently, we saw a Hello DDD demo written in Visual Code.
Elton says he’ll put up the PiWebApp on Github soon.
We saw how to publish using .NET Core. There were lots of binaries, totalling 9MB.
He then introduced Docker as a simplified way to do deployments. He said human release documents are always out of date, and come with configuration headaches.
We learned that an alternative to Ubuntu will be Windows Nano Server, but the Docker file size will be larger — about 400MB instead of 200MB.
We saw the docker file with
FROM
COPY
EXPOSE
WORKDIR
CMD
We also saw hub.docker.com for finding published files.
So Docker’s slogan is “Build, Ship, Run” and it makes DevOps easier. Developers can just give Ops the docker images.
Elton also covered Docker Swarm which offers:
- Clustering
- Scheduler
- Orchestration
It’s a cluster of machines running Docker, treated as a single unit.
We saw Docker for Azure, a new product with a Beta programme.
Elton showed us that Docker sends us an email containing a link to an ARM template.
He demonstrated the Docker Swarm Routing Mesh feature.
The final demo was Scaling Services.
Meanwhile the following other talks were going on:
Understanding your NFRs to make better software decisions — Nigel Dyson
Building (micro) services in .NET — Sean Farmar
Building rich client-side apps using Angular 2 — Joseph Woodward
Craig Philips attended and has reviewed this one.
Swag Giveaway
The vast majority of the attendees stayed until the end of the day for the Swag Giveaway. The top prize of two tickets for a choice of either the London, Oslo or Sydney NDC Conference was won by Richard Tasker.
Many others won books and T-Shirts. Finally a big box of Xamarin Monkeys were thrown down from the top of the stairs.
Thanks to all of the speakers, to the sponsors and the volunteers for this event. Thank you for reading, and if you attended this event as well please consider contributing so that we can move towards a complete write up of the day.
