Dean Silfen dsilfen-handy

Refactoring Ruby: Chapter 2

Principles in refactoring

What is refactoring?

Fixing code the second time around, because programmers rarely write good code the first time

Noun: a change to made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behavior

Pragmatic Programmer: Chapter 6

What to think about while writing code

Programming By Coincidence

Untrue assumptions are like landmines, and tend to blow up in our faces at inopportune times.
Before changing code, one should have a good handle understanding of how the current implementation works.

Pragmatic Programmer: Chapter 3

Learning basic tools to feel comfortable constructing your own toolkit

Power of plain text:

Insurance against obsolescence
- Self describing data carries context with data. Look at application.yml to see keys and their meaning. Many elements describe their purpose with their name.
Leverage
grep/ag/ruby/python/perl/bash/sh

Chapter 6 - Acquiring Behavior Through Inheritance

What is inheritance?

Automatic Message Delegation - Defining a path for forwarding messages an object does not understand.
Defining an inheritance relationship will automatically forward messages from the child to the parent if they are misunderstood (or if they are explicitly called with super
Multiple Inheritance VS. Single Inheritance
- Languages like Python allow more than one parent class
- Ruby features single inheritance

Rake it 'Til you make it

Tips on making resiliant rake tasks for data cleanup

Your script should have the following features:

Print the output, show progress in the stdout to make it
Provide a limit argument, so you can test on a small subset
Provide a offset argument, so you can skip already processed rows

Chapter 2 - Single Responsibility Principle (SRP)

What belongs in a `class`?

Flexible code as a truth

T.R.U.E.
- Transparent: Consequences of changing the code should be obvious in the code it is changing and in distant code it relies upon
- Reasonable: The cost of changing the code should be porportional to any benefits one might gain. (Small change == Small gain, big change == big gain)
- Usable: Existing code should be usable in new and unexpected contexts

Chapter 1 - Principles of OOP

Problems to solve

Flexibility (The only certainty in life is change!)
Dependency Management
Cost of development
- Avoiding design that anticipates future feature requirements

Definition of Design

ActiveGripes

MyProblems::With::ActiveRecord

What does << actually do for a has_many relation
Use of transactions with find_or_create_by
Are you sure you exist?
Racing to find_or_create records!

	grep shotgun docker-compose.development.yml
	if [ $? -eq 0 ] ; then
	perl -p -i -e "s/shotgun/unicorn/g" docker-compose.development.yml
	else
	perl -p -i -e "s/unicorn/shotgun/g" docker-compose.development.yml
	fi

	CURRENT_BRANCH=$(git describe --contains --all HEAD)
	PREVIOUS_BRANCH=$(git for-each-ref --sort=committerdate refs/heads/ \| tail -n 1 \| cut -c 60-)
	TWO_BACK_BRANCH=$(git for-each-ref --sort=committerdate refs/heads/ \| tail -n 2 \| head -n 1 \| cut -c 60-)
	if [[ $CURRENT_BRANCH == $PREVIOUS_BRANCH ]]; then
	GITCOMMAND="git checkout ${TWO_BACK_BRANCH}"
	else
	GITCOMMAND="git checkout ${PREVIOUS_BRANCH}"
	fi

	eval $GITCOMMAND