Practices for Success in DevOps

Kaizen is a popular dev ops cultural practice – means change for the better and we might roughly translate it to continuous improvement

Going to the actual place where the value’s created or where the problem is

Management by walking around

Define what you intend to do and what you expect the results to be, then you execute on that. Then you analyze the result and make any alterations needed

If newest plan is better than previous base line, it’s now the new base line

Plan, do, check, act gives people critical thinking skills

Five Whys, when there’s a problem, you ask the question why did it happen? And when you get an answer you ask why did that happen? Yu can repeat this as much as necessary, but five times is generally enough to exhaust the chain down to the root cause

Focus on underlying causes not symptoms (don’t accept answers like not enough time, do not accept human error as a root cause)

Agile Software Development

Process is iterative

Stresses collaboration

Promotes sustainable development

Waterfall goes through stage by stage

Seven Principles of Lean Software

Eliminate waste

Amplify learning

Decide as late as possible

Decide as fast as possible

Empower the team

Build in integrity

See the whole

Muda: work that absorbs resources but adds no value

Muri: unreasonable work imposed on workers and machines

Mura: work coming in unevenly instead of a constant or regular flow

Seven Wastes of Software

Partially done work

Extra feature

Relearning

Handoffs

Delays

Task switching

Defects

Build – Measure – Learn

Build the minimum viable product

Measure the outcome and internal metrics

Learn about your problem and your solution

Repeat. Go deep where it’s needed

Continuous Delivery

Code is always in a working state

Continuous Integration is the practice of building and unit testing the entire application frequently

Continuous Delivery is the additional practice of deploying every change to a production like environment and performing automated integration and acceptance testing

Continuous Deployment extends this to where every change goes through full enough automated testing. It’s deployed automatically to production.

Time to market goes down with continuous delivery

Quality increase, not decreases – gives room for experimentation

Limits your work in progress

Shortens lead times for changes

Improves mean time to recover

Builds should take less than five minutes

Make smaller commits

Don’t leave the build broken

Use a trunk-based development flow

Don’t allow flaky tests

Build should return a status, a log, and an artifact

Continuous Delivery Pipeline

Only build artifacts once

Artifacts should be immutable – doesn’t change during different stages

Deployment should go to a copy of production

Stop deploys if a previous step fails

Deployments should idempotent

Continuous Delivery: need to focus more on testing

Unit testing

Code hygiene (linting, formatting)

Integration testing

Security testing

TDD/BDD/ATDD (test-driven development – state desired outcome as a test, write code to pass the test, repeat; behavior-driven development – work with stakeholders, describe business functionality, tests are based on natural language descriptions; acceptance-test-driven development – end user perspective, use case automated testing, testing is continuous during development)

Infrastructure testing (starting up hosts)

Performance testing (load tests, etc good for nightly runs)

Container

Bundle app and dependencies in container and use that as the deployable artifact

The other day I worked on putting together a PHP CMS from scratch, and I learned a little bit about how to set up my environment for running the application locally. So for anyone who is looking for a bit of a reference, below is more information outlining the steps for setting up the environment.

Mac Installation

The web server (Apache) involved with PHP applications is built-in with a Mac

httpd -v (on command line to see what version of apache is installed on machine)

Additional Info

echo is used to print text

For comments, // and # are used for single line

How PHP Communicates with the Browser

The browser sends a request to server (Apache). Apache finds the file, processes it if it requires processing (sometimes it might need to go back and forth between the database), then it assembles the html and ships it back to the browser.

Properties for the models:

JSON stands for JavaScript Object Notation. It’s the text format used for sharing data, and is the most popular data transmission format. JSON is used for local data while JSONP is used for remote data.

Here are a few other things to keep in mind about this data format:

JSON is language independent (it’s available in php, Python, etc)

JSON keys are wrapped in quotes

JSON keys can be any valid string

Special characters can make it difficult to access data, and you should use underscores instead of hyphens

JSON has to be parsed into JavaScript (which can be done with eval or JSON.parse – JSON.stringify does the opposite of parse)

A great alternative to XML

JSONP

Stands for JSON with padding

Used for cross domain requests

Request URL incorporates the name of a callback function according to syntax defined by the service you’re using

Response Formats

JSON object

JSON array

JSONP (function)

Browsers enforce same-origin policy

Cross-Site Script Injection (XSSI)

Protecting against XSSI – can strip out malformed code

If downloaded directly, it isn’t parsed and creates an error

Alternatives to JSON

XML

Extensible Markup Language

Was widely used before JSON became popular

We can convert JSON to XML with different services

YAML

Was created to be human readable

Another language used to interchange data on the web

Uses white space, including indents and blank lines, which increases the size of YAML but makes it easier for humans to read

PHP is an open-source, server-side scripting language that was designed to be used with HTML. It can be object-oriented, and here is an overview of some of its features:

Data Types

Arrays

To create a variable and assign it to an empty array, use the following format $newarr = array();

To create a variable and assign it to an array, use: $newarr = array(1,2,3,4,5,6);

Associative Arrays

Associative arrays are an object-indexed collection of objects, used when you need a key to retrieve data.

Constants

The value of constants doesn’t change.

Use quotes when defining the constant, define("CONST_VALUE", 10), once it’s been defined, don’t use the quotes when referencing it.

You can’t redefine constants.

Booleans

When PHP outputs ‘true’ into a string, it outputs 1. For ‘false,’ it outputs nothing.

To check if a variable is a boolean, use is_bool();

True and False can be written in uppercase or lowercase

Floats

round(number1, number2) takes a number and how many significant digits you want there to be

ceil(number) ceiling always rounds up

floor(number) floor always rounds down

is_float(number) to determine whether something is a float

Functions

strtolower() changes a string to lower-case

strtoupper() changes a string to upper-case

ucfirst() changes first letter in string to upper-case

ucwords() changes first letter of every word in the string to upper-case

strleng() finds length of the string

trim() eliminates white spaces

strstr() find a string within a string (pass two parameters). Find a string within a string

str_replace() takes three parameters – the string you’re looking for, what you want to replace it with, and the item we’re searching in

Integers

abs(0 - 100) absolute value

pow(3, 6) exponential (first number to the power of the second number)

sqrt(25) square root

fmod(17, 3) modulo

rand() random

rand(1,20) random (min, max)

is_int(number) to determine whether something is an integer

Null and Empty

Case insensitive

is_null(); will test if an item is null

An empty string, null, 0, 0.0, “0”, false, and an empty array, are all considered items that are empty

Strings

Strings can include letters, text, html.

Use double quotes or single quotes to denote strings

Can do variable replacement inside of a string (but only when you use double quotes):

<?php$phrase="Hello World";?><?phpecho"$phrase printed here<br>";?>

For in place substitution, use echo "{$phrase} Here<br>";

Debugging

Use <?php phpinfo(); ?> to access more information about the configurations

Missing semicolons are a common problem

To turn on error reporting, in the php.ini file, display_errors = On and error_reporting = E_ALL, in PHP code, ini_set('display_errors', 'On'); and error_reporting(E_ALL);

Turn off error reporting on live websites

Use echo to make sure you’re getting the right values for variables

print_r($array); to print readable array

gettype($variable); to get variable type

var_dump($variable); to get type and value

get_defined_vars(); array of defined variables

debug_backtrace(); show backtrace

Encoding

For GET requests to pass a reserved character, you must encode them with urlencode($string) – letters, numbers, underscores, and dashes will be unchanged, but reserved characters become % + 2-digit hexidecimal, and spaces become +

For rawurlencode, letters, numbers, and dashes are unchanged, reserved characters become % + 2-digit hexidecimal, and spaces become %20

Use rawurlencode for the path, before the “?” section, and uses urlencode on the query string

If you already use npm, you’re probably wondering what’s the point of Yarn?

Yarn is a somewhat new JavaScript package manager created by the engineers at Facebook.

It’s a faster and more secure dependency manager

It uses an offline cache – so after you’ve installed a package using Yarn, it will be available on your machine for offline access.

Quite honestly, what really reeled me in with Yarn was the speed at which it can install packages. It’s amazing how shaving off a few seconds from installing packages can really speed up your overall workflow.

Get Yarn

npm install –g yarn

Or use brew to add it. Once installed, you use the following format to add any dependency:

React is a user interface library that was developed at Facebook. React is written in different components and follows the principles of immutable data. It’s often used in enterprise applications, and it makes creating single page applications easier since they have a higher speed thanks to the virtual DOM. This means it writes to the browser DOM only when it is needed, instead of re-rendering an entire view when a change is made.

Virtual DOM

React creates an in-memory DOM where it only renders different parts of the DOM when a change occurs.

JSX

React utilizes JSX, which is a JavaScript extension syntax that allows you to quote HTML.

Babel

Babel is a transpiler that transpiles JavaScript code. It works for JSX as well as ES6 and beyond. Babel converts React’s JSX and ES6 to something the browser can use.

Components

React applications consist of a collection of components. Components are small user interface elements that display data as it changes over time. Used together, these components create entire user interfaces.

Component Lifecycle

Component lifecycles allow you to add libraries and load data at specific times. They also help improve the speed of an application, with lifecycle methods that you can override to run code a specific times in the process.

Mounting methods are called when an instance of a component is being created: