Reading challenge for myself

I've decided to make a personal challenge for myself.

If I finish reading the classic C Programming Language book, then I'll let myself by The Go Programming Language book that's also written by Kernighan.

My goal is to read the book over the course of a month, but the Go book isn't coming out until August so I do have a bit of time. :)

C Programming Language (2nd Edition)

More about this product

The Go Programming Language (Addison-Wesley Professional Computing Series)

~ Brian W. Kernighan (author) More about this product
List Price: $39.99
Price: $32.59
You Save: $7.40 (19%)


More tips on TDD

Four major parts of a test:

  1. Setup state: Arrange - Setup state (fixture) (Given...)
  2. Run application code: Act - Run application code (exercise System-Under-Test) (When...)
  3. Check expectations: Assert - Check if it worked (Then...)
  4. Cleanup state: Teardown

Different types of tests:

  • Stubs - check how data flows in a program
  • Mocks - use to avoid testing every combination of dependencies
  • Characterization - test after development (TAD) - take a snapshot of the current program

Notes on BDD / TDD

Notes / reminders for myself on BDD / TDD:

  • One of the keys to BDD is agreeing on the specs before development with the business owner and the QA engineer.
  • Do outside-in TDD. First, write the specs for the functional test level (e.g. Cucumber) and then write the specs at the unit test level.
  • If I'm struggling to write the test specs, simply write down in English what you are trying to do.
  • Get fast feedback. Only test the small section of tests that are relevant to the code you are changing. You can run the full suite of tests for continuous integration later.
  • Whenever you're testing a feature, you should have test cases where it works properly, and test cases where it doesn't work (e.g. throws an error) and you are checking to make sure you have proper error handling.
  • Write comments as much as possible while you're developing / writing tests. As you get ready to clean up for a commit / pull request, think about which comments can be turned into actions (e.g. renaming the method so the comment becomes obsolete).
  • Focus on testing the most important scenarios. While it's tempting to test every variation and every scenario, the cost is a heavy test suite that takes a long time to run, and therefore discourages people from running it as often as they would otherwise.
  • Write your specs so they are detailed. Avoid overly terse specs such as "setupForm():". Add additional context where it makes sense such as "setupForm(): make sure all form fields accept the appropriate types of inputs".
  • When testing a class, focus on test coverage for all the major functionality / entry points. Testing every method will result in a tight coupling between the tests and the implementation.

Software Engineering Goals

I've decided to break down my learning goals for this upcoming year into three quarters since there's 9 months left. 

Q1: Fundamentals - April - June:

  • Practice TDD and BDD (when possible)
  • Practice refactoring and documenting (comments & wiki)
  • Learn Python
  • Fluent in RegEx
  • Proficient in testing tools & framework (selenium, cucumber, visual/ui)
  • Read books:
    • Introducing Python
    • Refactoring
    • Don't make me think
    • Clean Code
    • Code Complete
    • The Mythical Man-Month

Q2: Patterns - July - September:

  • Fluent in Python for data analysis (Pandas)
  • Typescript
  • Read the classics:
    • Rapid Development
    • Implementing Domain-Driven Design
    • Phoenix Project
    • Essential Scrum
    • Kanban

Q3: Systems-level - October - December:

  • Learn Go and create a simple project / web service
    • Do a toy project (HTTP server for a simplified GitHub)
    • Contribute to Docker & Hashicorp's projects
  • Read systems / cloud books:
    • Go Language
    • Cloud Architecture Patterns
    • Working with Unix process
    • Web Services, SOA
    • DevOps trouble shooting

De-prioritize the following topics:

  • Languages outside of Javascript variants (e.g. Coffeescript, Typescript), Python, and Go
  • Only focus on these 3 major Javascript libraries: Angular, React, and Meteor
    • Not worth spending time reading about various MVC frameworks, Derby, Sails, etc.
  • Not too much on database - just maintain a basic working knowledge of SQL (Postgres) and MongoDB
  • Just learn basic design, CSS, and Sass
  • awk & sed - just don't think I'll use it that much
  • Vim - takes way to much time to create and maintain vimrc (and using other people's still takes a lot of time to familiarize). Just stick with Webstorm
    • Along that note, I don't think tmux is really worth it for me to use as well
  • Don't spend too much time reading Hacker news
  • Avoid proactively searching out chances to respond to Stack Overflow responses - only do it if you happen to come across it
  • Stick with Bootstrap - by far the most popular CSS framework
  • Until the last quarter, don't spend time on DevOps topics like Mesos, Kafka, Storm, etc