x =
    ^

x = canvas.drawString(
                      ^

x = canvas.drawString(margin + (
                                ^

x = canvas.drawString(margin + (indent[
                                       ^

x = canvas.drawString(margin + (indent[LEFT] / 2
                                                ^

x = canvas.drawString(margin + (indent[ ]))
                                       ^

//  sgp4fix for afspc written intrinsic functions
// nodep used without a trigonometric function ahead
if ((nodep < 0.0) && (opsmode == 'a'))
    nodep = nodep + twopi;
xls    = mp + argpp + cosip * nodep;
dls    = pl + pgh - pinc * nodep * sinip;
xls    = xls + dls;
xnoh   = nodep;
nodep  = atan2(alfdp, betdp);

#   sgp4fix for afspc written intrinsic functions
#  nodep used without a trigonometric function ahead
if nodep < 0.0 and opsmode == 'a':
    nodep = nodep + twopi;
xls    = mp + argpp + cosip * nodep;
dls    = pl + pgh - pinc * nodep * sinip;
xls    = xls + dls;
xnoh   = nodep;
nodep  = atan2(alfdp, betdp);

xnodce = fmod(4.5236020 - 9.2422029e-4 * day, twopi);
stem   = sin(xnodce);
ctem   = cos(xnodce);
zcosil = 0.91375164 - 0.03568096 * ctem;
zsinil = sqrt(1.0 - zcosil * zcosil);

xls    = xls + dls;
xnoh   = nodep;
nodep  = atan2(alfdp, betdp);

print foo
print dir(foo)
print foo.bar
print len(foo.bar)
print foo.bar[1]
print dir(foo.bar[1])
print foo.bar[1].baz

$('div').parent().find('h1')
     .attr('data-level', '1')
     .css('display', 'block')

print foo
print foo.dir()
print foo.bar
print foo.bar.len()
print foo.bar[1]
print foo.bar[1]
print foo.bar[1].baz

foo.add(bar)
bar.add(foo)

cat log |
    grep 'Connection error' |
    awk '{print $2}' |
    sort |
    uniq -c

inputfile sort paginate printerfile

tr -cs A-Za-z '\n' |
tr A-Z a-z |
sort |
uniq -c |
sort -rn |
sed ${1}q

a + b + c

f(a)

(+ a b c)
(f a b c)

(* (+ a b) m)
(output (concat page1 page2) printer)

(list (nth 0 ad-return-value) ;; original word
      (nth 1 ad-return-value) ;; offset in file
      (remove-if 'contains-space-p
                 (nth 2 ad-return-value))
      (remove-if 'contains-space-p
                 (nth 3 ad-return-value))
      ))))

  ↘
x + y

      ↘
x + y + z

  ↙       ↘
ln(x + y + z)

 ↙
- ln(x + y + z)

a + b * c

b * c + a

a + b*c

a + (b * c)

a.b() + c[d]

(a -b)  # Python - one possible meaning
(a -b)  # Ruby - two possible meanings

a = (3 * 4) + 5

# is ALWAYS equivalent to

t = (3 * 4)
a = t + 5

a = spreadsheet.compute('D4')

c = spreadsheet.compute  # attr lookup
c('D4')              # invoke callable

# Python is so awesome

draw = canvas.drawString
draw(60, 120, 'A rose is a rose.')

import piano
piano.Bench()      # yes!

import piano
piano.PianoBench()  # no!

class Logger
class Handler
class Filter

class LogRecord

import json
json.loads(...)
json.dumps(...)

# not json_load() or jdump()

\ddangerexercise Since \TeX\ reads an entire
paragraph before it makes any decisions about line
breaks, the computer's memory capacity might
^^{capacity exceeded} be exceeded if you are
typesetting the works of some ^^{Joyce, James}
^{philosopher} or modernistic novelist who writes
200-line paragraphs. Suggest a way to cope with such
authors.
\answer Assuming that the author is deceased and/or
set in his or her ways, the remedy is to insert
`|{\parfillskip=0pt\par\parskip=0pt\noindent}|'
in random places, after each 50 lines or so of]
text. \ (Every space between words is usually a
feasible breakpoint, when you get sufficiently
far from the beginning of a paragraph.)

$$ 1 + \left( 1 \over 1 - x^2 \right)^3 $$

canvas.drawString(x, y,
    'Please press {}'.format(key))

message = 'Please press {}'.format(key)
canvas.drawString(x, y, message)

message = 'Please press {}'.format(key)
canvas.drawString(x, y, message)

widget.reset(True)  # forces re-draw

yes_force_redraw = True
widget.reset(yes_force_redraw)

...

# Open the barn

barn = models.Barn.get()
barn.unlock()
barn.open()

# Saddle the horse

...

    ...
    open_barn()
    saddle_horse()
    ...

def open_barn():
    barn = models.Barn.get()
    barn.unlock()
    barn.open()

# React if window too tall

if win.x1 - win.x0 > vp.h:
    ...

too_tall = (win.x1 - win.x0) > vp.h
if too_tall:
    ...

# Yes:
x = 1
y = 2
long_variable = 3

# No:
x             = 1
y             = 2
long_variable = 3

for item in sequence:
    if is_valid(item):
        if not is_inconsequential(item):
            item.do_something()

for item in sequence:
    if not is_valid(item):
        continue
    if is_inconsequential(item):
        continue
    item.do_something()

def mymethod(self):
   for item in sequence:
       if item.is_good():
           for widget in item:
               ...

def mymethod(self):
    for item in sequence:
        if item.is_good():
            for widget in item:
                self.finalize(widget)

def finalize(self, widget): ...

def mymethod(self):
   for item in sequence:
        if item.is_good():
            self.finalize_widgets(item)

def finalize_widgets(self, item):
    for widget in item:
        widget.close()

    def mymethod(self):
        for item in self.sequence:
            if item.is_good():
                _finalize_widgets(item)

def _finalize_widgets(item):
    for widget in item:
        widget.close()

for item in sequence:
    for widget in item:
        for bitmap in widget:
            for pixel in bitmap:
                pixel.align()
                pixel.darken()
                pixel.draw()

def widget_pixels(sequence):
    for item in sequence:
        for widget in item:
            for bitmap in widget:
                for pixel in bitmap:
                    yield pixel

for pixel in widget_pixels(sequence):
    pixel.align()
    pixel.darken()
    pixel.draw()

foo = long_function_name(var_one, var_two,
                         var_three, var_four)

asymtotic_reduction(arg1, arg2)

asymtotic_reduction(arg1, arg2,
                    arg3, arg4)

asymtotic_reduction(arg1, arg2,
                    arg3, arg4,
                    arg5)

asymtotic_reduction(arg1, arg2,
    arg3, arg4, arg5)

asymtotic_reduction(arg1, arg2,
    die_on_error=arg3, heigth=arg4,
    width=arg5 / 2.0 + COLUMN_WIDTH)

asymtotic_reduction(
    x=arg1,
    y=arg2,
    die_on_error=arg3,
    height=arg4,
    width=arg5 / 2.0 + COLUMN_WIDTH,
    )

asymtotic_reduction(
    die_on_error=arg3,
    height=arg4,
    width=arg5 / 2.0 + COLUMN_WIDTH,
    )

    x := sin(a);
    y := cos(a)
End;
        ↓
    x := sin(a);
    y := cos(a);  # CHANGED
    z := tan(a)   # NEW
End;

int biglist[] = {
    112,
    223
};

        ↓

int biglist[] = {
    112,
    223,    # CHANGE
    334     # NEW
};

big_tuple = (
    12,
    23,
    )
big_list = [
    34,
    45,
    ]
big_dict = {
    'one': 1,
    'two': 2,
    }

asymtotic_reduction(
    x=arg1,
    y=arg2,
    die_on_error=arg3,
    height=arg4,
    width=arg5 / 2.0 + COLUMN_WIDTH,
    )

canvas.drawString(x + margin, y - line_height,
                  'The Naming of Cats')

if (width == 0 and height == 0 and
    color == 'red' and emphasis == 'strong' or
    highlight > 100):

adjusted_income = (gross_wages +
    taxable_interest +
    (dividends - qualified_dividends) -
    ira_deduction -
    student_loan_interest)

adjusted_income = (gross_wages +
    taxable_interest +
    (dividends - qualified_dividends) -
    ira_deduction -
    student_loan_interest)

adjusted_income = (gross_wages
    + taxable_interest
    + (dividends - qualified_dividends)
    - ira_deduction
    - student_loan_interest)

# UGH BAD HURTS MY EYES

query = Person.filter(last_name='Smith') \
    .order_by('social_security_number') \
    .select_related('spouse')

query = Person.filter(last_name='Smith'
    ).order_by('social_security_number'
    ).select_related('spouse')

query = (Person.
    filter(last_name='Smith').
    order_by('social_security_number').
    select_related('spouse')
    )

query = (Person
    .filter(last_name='Smith')
    .order_by('social_security_number')
    .select_related('spouse')
    )

query = (Person.
    .filter(last_name='Smith')
    .order_by('social_security_number')
    .select_related('spouse')
    )

q = Person.filter(last_name='Smith')
q = q.order_by('social_security_number')
q = q.select_related('spouse')