Software Engineering

What can software do?

Everything

Websites and Apps

Games

Science

Robotics

Accounting

Any Business

Software is eating the world.

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

The art of programming is the art of organizing complexity, of mastering multitude and avoiding its chaos as effectively as possible.

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

Programs must be written for people to read, and only incidentally for machines to execute

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

Object Oriented Programming (OOP):

Java, C++

Functional Programming (FP):

Haskell, Clojure, Lisp

Multi-paradigm:

Python, Ruby