What can software do?

Everything

Websites and Apps

Games

Science

Robotics

Accounting

Any Business

What is Code?

Instructions for the computer to execute

Descriptions of algorithms

for block, next_block in _peeking_iterator(iterable):
    encrypted = leftover + block
    offset = (len(encrypted) / block_size) * block_size
    decrypted = decoder.decrypt(encrypted[:offset])
    leftover = encrypted[offset:]

    if strip_final_padding and not next_block:
        decrypted = decrypted[0:-ord(decrypted[-1])]

    if decrypted:
        yield decrypted

Crystallized Complexity

What is it like to be a software engineer?

Translate feature requirements into algorithms

Visualize abstract structures

Organize complexity

At first, the hardest part is writing for the machine

Then, the hardest part is writing for humans

def generate_file(runs):
    variable_order = None
    for run in runs:
        if not variable_order:
            variable_order = [v.name for v in run.input_variables]
            yield ','.join(variable_order) +'\n'
      sorted_names = sorted(v.name for v in run.input_variables)
      if sorted_names != sorted(variable_order):
          raise ValueError(
              'Mixed runs with different variables'
          )
      sorted_variables = sorted(
        run.input_variables,
        key=lambda v: variable_order.index(v.name)
      )
      values = [str(v.value) for v in variables]
      yield ','.join(values) + '\n'

def generate_file(runs):
    variable_order = None
    for run in runs:
        if not variable_order:
            variable_order = _names(run.input_variables)
            yield _make_line(variable_order)

        yield _make_line(_var_values(run, variable_order))

def _make_line(values):
    return ','.join(values) + '\n'

def _names(run_variables):
    return [v.name for v in run_variables]

def _var_values( run, var_names):
    run_variables = run.input_variables
    if sorted(_names(run_variables)) != sorted(var_names):
        raise ValueError(
            'Mixed runs with different variables, '
            'expected {0}, got {1}'.format(
                var_names, _names(run))
        )
    return [
        str(v.value) for v in
        sorted(run_variables, key=lambda var: var_names.index(var.name))
    ]

Language Philosophies