Starred Notes from Indy.Code() 2018

April 19, 2018 // irl

I was fortunate enough to be back at Indy.Code() for year 2 and try out the workshops as well this time around.  Similar to before, I wanted to share some highlights from the sessions I attended. 🙂  I also bolded the biggest takeaway from each session, in case you want to skim even faster.

Please keep in mind this is only my paraphrasing or lessons learned from each talk, and may not be even remotely accurate of what the speaker was trying to convey.  We all hear what we want to hear.. 😉

Going all in with functional C# – Ed Charbeneau

  • Imperative and functional programming do not need to be mutually exclusive with C#
  • A key value of functional programming is further separation of data and behavior from each other
  • Functional programming can lead you to more isolated code that is more maintainable and easier to test
  • Extension methods enable method chains that can be used as an alternative to pipes in other languages

Practical Machine Learning with Python – Matthew Renze

  • Classification, regression and clustering are three high level clusters of machine learning algorithms
  • Goodness of fit is how a new data set performs when evaluated against a model.  Underfitting means you haven’t made a complex enough model and overfitting means you haven’t made a simple enough model.
  • Curse of dimensionality is the problem that as more features are added there is an exponential growth in the data needed to have a densely populated data set.

A New Vue for Web Development – Chad Campbell

  • Created by Evan You, who worked on AngularJS
  • There are many similar constructs to AngularJS (e.g. templates, directives)
  • Components are the key building block
  • There is a native router that you can opt-into or replace

Embracing the Mob Mentality – R. Michael Rogers

  • If at the end of an 8hr day your code was printed out and you had to re-enter it, on average ~30 minutes
  • We are knowledge workers, not typists.
  • Relying on the group to think about non-trivial problems can actually reduce one of the biggest slow downs in development – the hours when you get stuck on a problem and can’t immediately see through it by yourself.
  • When mobbing, get each person to the keyboard every hour
  • Patience is critical, the primary goal isn’t maximum throughput but common knowledge of the solution

Cryptography Best Practices – Christopher Lomont

  • AES is the foundation of modern cryptography
  • Asymmetric encryption is 500-1000x slower to compute than symmetric encryption
  • Common to use asymmetric for handshaking a symmetric key (e.g. TLS/SSL)
  • Thermodynamic laws have been used to calculate how much energy it would take to brute force different solutions

Giving Clarity to LINQ Queries by Extending Expressions – Ed Charbeneau

  • Expressions are representations of code as data
  • IEnumerable is a Func<T> whereas IQueryable is an Expression<Func<T>>
  • You can use extension methods as a way to wrap up complex functionality into a named concept

The Future of Programming – Jimmy Miller

  • Idris is attempting to answer the question “What if our programs were proofs?” by embedding the concept of mathematical proofs into the language to truly eliminate bugs
  • Unison is attempting to answer the question “What if other machines were first class elements?” by baking distributed machine concepts directly into the language
  • Eve was attempting to answer the question “What if anyone could program?” by making a language as approachable as Excel

Know Your Tools – Making the Most of Working with .NET Core – Dave Rael

  • Chocolately and boxstarter can automate new machine setup
  • The better you are with your tools the less you fall out of context (flow) when solving problems
  • Visual Studio’s powerful debugger may unfortunately lead people away from unit testing

Micro-Services: What we learned from 2017 (a.k.a. Microservice Manifesto) – Chase Aucoin

  • While the monolith is the most agile in the beginning, microservices are the most agile in the long run
  • Scaling your teams is just as important as scaling the software
  • Containers have more value in Java/Linux world where you have to orchestrate together more disparate elements
  • If what you have is working, it isn’t time to change your architecture
  • Remember to breathe, it’s just code.

Exploring the Foundations of Programming – Jimmy Miller

  • An object is really just a construct that responds to messages
  • Functions are the most fundamental feature of programming
  • Functional programming is heavily built on top of lambda calculus

Learning The Basics In R programming – Pierre DeBois

  • Why data science?  Because not all relationships are visible
  • Data science applies statistics to data
  • Data science is changing analytics from causal to behavioral

What I’ve Learned From Featuring Over 0x100 Developers on My Podcast – Dave Rael

  • The biggest lie is “I’m good with machines, not people”
  • We tell ourselves we don’t need to be good at interacting with people because we have other skills
  • You don’t have to be a celebrity to have something really valuable to share
  • Take care of yourself, have a growth mindset and practice empathy

Clean Code: Homicidal Maniacs Read Code, Too! – Jeremy Clark

  • There’s no such thing as write-once code
  • The biggest lie/obstacle to clean code is the statement “I’ll clean it up later”
  • Intentional naming is critical
  • “If you aren’t writing incremental code, you’re writing excremental code”
  • Follow the boy scout rule, leave it cleaner than you found it.

Indy.Code() 2018 Summary

I really enjoyed the conference again this year and am very grateful to have something pretty awesome so close to home.  A LOUD thank you to the organizers, speakers, sponsors, staff and everyone who participated in Indy.Code().. as well as to my employer Viral Launch for letting most of the team and I take the time out to sharpen the saw and refresh the passion for development. 🙂

Last year’s notes:

About the author

Steve Cadwallader is a software developer who geeks out on user interfaces, clean code and making things easier.


  1. Thank you so much for writing up your thoughts and summaries of the sessions, Steve!
    We are so glad you made it for year two and whole-heartedly welcome any feedback.

    Thanks, again! – Amegala

  2. Kindly advice you to dig into my .NET Core 2.1 Dependency Injection framework It has some interesting concepts that makes is useful in testing (especially with xUnit), DI and general programming.

Leave a Comment