Developer Efficiency

Dmitri Nesteruk
dmitrinesteruk@gmail.com

http://nesteruk.wordpress.com
dnesteruk
dmitri.nesteruk

!   Circa ~10yrs in .Net
!   C#, F#, Web (HTML+REST), WinForms, etc.
!   Founder & co-ordinator @ St. Petersburg
Alt.Net User Group (est. 2008, http://spbalt.net)
!   Podcast: http://spbaltnet.podfm.ru
!   Co-ordinator of the St. Petersburg .Net User
Group (Ineta, http://sp.ineta.ru)
!   Microsoft MVP – Visual C# (since 2009)

!   Developer evangelist @ JetBrains
!   Passionate .Net developer/consultant

!   Efficiency =
!   How quickly you write code
!   How good the code is
!   Efficiency is relative
!   Relative to how quickly other people code and
how good their code is
!   This talk is about
individual efficiency

!   No
!   Business model not conducive (e.g., monopoly)
!   Management doesn’t care
!   Billable hours (outsourcing, etc.)

!   Yes!!!
!   Product company
!   Start-up
!   Company with ‘engineering culture’

!   Intrinsic motivation a.k.a “professionalism”
!   “Programming is my pride and joy, I must improve
and do things better”

!   Extrinsic motivation
!   If I do things better, I’ll get more
money/respect/casual sex/whatever

!   Eﬃciency is largely individual.
Team eﬃciency is ƒ(individuals).

!   How quickly can you write code?
!   Especially mundane code
!   How quickly can you
!   Compile
!   Run tests
!   Deploy
!   Do you need to recompile to ﬁx a program?

!   Mnemonics
!   Used to create data structures
!   Code gen features
!   Create routine code quickly
!   Custom-written features, e.g.,
!   Dispose(), IDisposable
! INotifyPropertyChanged

!   Compilation and testing eats local CPU
!   VS2010 and earlier also freezes UI :(
!   You need results now, not after check-in
!   Single-machine solution:
!   Use other (fast) machines to build/test
!   Use Dropbox (or similar) to sync
!   Build via MSBuild with /m option
!   Use a test runner that automatically re-runs tests
when binaries change
!   E.g., Gallio Icarus

!   Multi-machine solution:
!   Compilation:
!   Build project dependency graph
!   Topological sort
!   Run MSBuild on individual projects
!   File sync
!   Testing:
!   Quantize by assembly (DLL), ﬁxture or method
!   Execute on separate machines
!   Collate results (XML merge) and present
!   Existing solutions: IncrediBuild, Electric Cloud

!   What about Continuous Integration?
!   Multiple TC configurations on multiple
machines
!   All will (probably) have to compile everything
!   But different agents can run different things
!   Difficult to coordinate!

!   Only worth it if
!   Cost is high (e.g., compilation time > 5sec.)
!   Is automated
! Spolsky’s “Can you make a build in one step?”
!   Parallelizable (often, not always)
!   Does not have cryptic dependencies, magic
artefacts
!   Caveat: on remote machines, you lose out on
VS integration

!   Conditionally show a lightweight editor
!   I use ActiPro, so I have some IntelliSense
!   Instantiate new component and update usage
!   Stick to one-class-per-file rule
!   Judicious use of dependency injection
!   Write modified source code to original file
!   Benefits:
!   Eliminate close-recompile-restart cycle
!   Preserve memory state
!   See new features immediately

!   Code generation - R#, code-gen/UML/MDA
tools
!   AOP - PostSharp, your own MSBuild post-build
task for IL rewriting (via Mono.Cecil)
!   Dynamic programming - DynamicMethod,
LINQ Expression compiler, DLR
! Metaprogramming – Boo/Nemerle, Project
Roslyn (post-C#5), D (!)
!   Breaks language services (VS, C#)
!   DSLs – F#, MPS

!   Do developers have the best tools money can
buy? (as per Joel’s Test)
!   Tools =
!   Best software for development, quality control
!   Best hardware for development, compilation/
testing, virtualization, etc.
!   Best workspace equipment (here be dragons)
!   Do developers make their own development
tools?
!   Do developers perform R&D on new tools,
languages, frameworks?

!   IDE, refactoring support
!   IDEA, VS + ReSharper
!   Code insight tools
! FxCop, NDepend
!   Infrastructure tools
!   (D)VCS – Git, Mercurial
!   Yes, people do host commercial projects on Github
!   CI systems – TeamCity, Hudson, CC.Net
! Collabotartion tools – issue tracking, wiki,
VSAnywhere

!   Bare minimums
!   Modern CPU
!   Enough RAM (~16Gb+ as of 2011)
!   Laptops notwithstanding
!   SSDs (still using HDDs?!?)
!   Multiple monitors
!   Fast internet connection (duh!..)
!   Assume that dev software (e.g., VS) is power-
hungry and always expects top-end computers

!   Fast computers allow a lot more intelligence on
developers’ machines
!   Resource-heavy code analysis
!   R# misspelt naming (GPGPU)
!   Larger, faster, mode detailed caches
!   Fuzz/Monte-Carlo testing/simulation
!   Integration tests (VMs etc.)

!   More time is spent on solving problems rather than
implementation
!   Strong AI ain’t here yet
!   Development depends on lots of other things
!   Quiet and adequate working conditions
(Joel’s Test)
!   Sensible management practices
!   Whether people are happy with their pay
!   … and a lot more.
!   YMMV – eﬃciency may or may note give you
anything.
!   No substitute for good business model.

!   Questions?
!   Answers?
!   Hate mail?
!   MOAR?!?

Developer Efficiency

More Related Content

What's hot

Similar to Developer Efficiency

More from Dmitri Nesteruk

Recently uploaded

Developer Efficiency