Ejercicios de estilo en la programación

Exercises in Style
Crista Lopes

PROGRAMMING STYLES
Rules and constraints in software construction

Programming Styles
⊳ Ways of expressing tasks
⊳ Exist and recur at all scales
⊳ Frozen in Programming
Languages

Why Are Styles Important?
⊳ Basic frames of reference for
solutions
• Like scaffolding
⊳ Common vocabularies
• It’s a cultural thing
⊳ Some better than others
• Depending on many things!

Programming Styles
How do you teach this?

Queneau’s Exercises in Style
⊳ Metaphor
⊳ Surprises
⊳ Dream
⊳ Prognostication
⊳ Hesitation
⊳ Precision
⊳ Negativities
⊳ Asides
⊳ Anagrams
⊳ Logical analysis
⊳ Past
⊳ Present
⊳ …
⊳ (99)

Queneau’s “Styles”
⊳ Constraints
⊳ “A Void” (La Disparition)
by Georges Perec
• No letter ‘e’

Exercises in Programming Style
The story:
Term Frequency
given a text file,
output a list of the 25
most frequently-occurring
words, ordered by decreasing
frequency

Exercises in Programming Style
The story:
Term Frequency
given a text file,
output a list of the 25
most frequently-occurring
words, ordered by decreasing
frequency
mr - 786
elizabeth - 635
very - 488
darcy - 418
such - 395
mrs - 343
much - 329
more - 327
bennet - 323
bingley - 306
jane - 295
miss - 283
one - 275
know - 239
before - 229
herself - 227
though - 226
well - 224
never - 220
…
TFPride and Prejudice

STYLE #1
@cristalopes #style1 name

# the global list of [word, frequency] pairs
word_freqs = []
# the list of stop words
with open('../stop_words.txt') as f:
stop_words = f.read().split(',')
stop_words.extend(list(string.ascii_lowercase))

for line in open(sys.argv[1]):
for c in line:

Style #1 Main Characteristics
⊳ No abstractions
⊳ No use of library functions

⊳ No abstractions
⊳ No use of library functions
Brain-dump Style

STYLE #2

import re, string, sys
stops = set(open("../stop_words.txt").read().split(",") + list(string.ascii_lowercase))
words = [x.lower() for x in re.split("[^a-zA-Z]+", open(sys.argv[1]).read()) if len(x) > 0 and x.lower() not in stops]
unique_words = list(set(words))
unique_words.sort(lambda x, y: cmp(words.count(y), words.count(x)))
print "n".join(["%s - %s" % (x, words.count(x)) for x in unique_words[:25]])
Credit: Laurie Tratt, Kings College London

stops = set(open("../stop_words.txt").read().split(",") +
list(string.ascii_lowercase))
words = [x.lower() for x in re.split("[^a-zA-Z]+",
open(sys.argv[1]).read())
if len(x) > 0 and x.lower() not in stops]
unique_words.sort(lambda x, y: cmp(words.count(y),
words.count(x)))
print "n".join(["%s - %s" % (x, words.count(x))
for x in unique_words[:25]])

stops = set(open("../stop_words.txt").read().split(",") +
list(string.ascii_lowercase))
words = [x.lower() for x in re.split("[^a-zA-Z]+",
open(sys.argv[1]).read())
if len(x) > 0 and x.lower() not in stops]
unique_words.sort(lambda x,y:cmp(words.count(y),
words.count(x)))
print "n".join(["%s - %s" % (x, words.count(x))
for x in unique_words[:25]])

⊳ As few lines of code as possible

Code Golf Style

Try Hard Style

STYLE #3

#
# Main
#
read_file(sys.argv[1])
filter_normalize()
scan()
rem_stop_words()
frequencies()
sort()
for tf in word_freqs[0:25]:
print tf[0], ' - ', tf[1]
def read_file(path):
def filter_normalize():
def scan():
def rem_stop_words():
def frequencies():
def sort():
data=[]
words=[]
freqs=[]

⊳ Procedural abstractions
• maybe input, no output
⊳ Shared state
⊳ Larger problem solved by
applying procedures, one after
the other, changing the shared
state

⊳ Procedural abstractions
• maybe input, no output
⊳ Shared state
⊳ Commands
Cook Book Style

STYLE #4

#
# Main
#
wfreqs=st(fq(r(sc(n(fc(rf(sys.argv[1])))))))
for tf in wfreqs[0:25]:
print tf[0], ' - ', tf[1]
def read_file(path):
def filter(str_data):
def scan(str_data):
def rem_stop_words(wordl):
def frequencies(wordl):
def sort(word_freqs):
def normalize(str_data):
return ...
return ...
return ...
return ...
return ...
return ...
return ...

⊳ Function abstractions
• f: Input  Output
⊳ No shared state
⊳ Function composition f º g

⊳ Function abstractions
• f: Input  Output
⊳ No shared state
⊳ Function composition f º g
Chocolate Factory Style
Image credit: Nykamp DQ, From Math Insight. http://mathinsight.org/image/function machines composed
g
f

STYLE #5

def read_file(path, func):
...
return func(…, normalize)
def filter_chars(data, func):
...
return func(…, scan)
def normalize(data, func):
...
return func(…,remove_stops)
# Main
w_freqs=read_file(sys.argv[1],
filter_chars)
for tf in w_freqs[0:25]:
print tf[0], ' - ', tf[1]
def scan(data, func):
...
return func(…, frequencies)
def remove_stops(data, func):
...
return func(…, sort)
Etc.

⊳ Functions take one additional
parameter, f
• called at the end
• given what would normally be the
return value plus the next function

⊳ Functions take one additional
parameter, f
• called at the end
• given what would normally be the
return value plus the next function
Crochet Style

STYLE #6

class DataStorageManager(TFExercise):
class TFExercise():
class StopWordManager(TFExercise):
class WordFreqManager(TFExercise):
class WordFreqController(TFExercise):
# Main
WordFreqController(sys.argv[1]).run()
def words(self):
def info(self):
def info(self): def info(self):
def info(self):
def is_stop_word(self, word):
def inc_count(self, word):
def sorted(self):
def run(self):

⊳ Things, things and more things!
• Capsules of data and procedures
⊳ Data is never accessed directly
⊳ Capsules can reappropriate
procedures from other capsules

⊳ Things, things and more things!
• Capsules of data and procedures
⊳ Data is never accessed directly
⊳ Capsules can reappropriate
procedures from other capsules
Kingdom of Nouns Style

STYLE #7

class DataStorageManager():
class StopWordManager():
class WordFrequencyManager():
class WordFrequencyController():
def dispatch(self, message):
# Main
wfcntrl = WordFrequencyController()
wfcntrl.dispatch([‘init’,sys.argv[1]])
wfcntrl.dispatch([‘run’])

⊳ (Similar to #6)
⊳ Capsules receive messages via
single receiving procedure

⊳ (Similar to #6)
⊳ Capsules receive messages via
single receiving procedure
Letterbox Style

STYLE #8

# Main
splits = map(split_words,
partition(read_file(sys.argv[1]), 200))
splits.insert(0, [])
word_freqs = sort(reduce(count_words, splits))
for tf in word_freqs[0:25]:
print tf[0], ' - ', tf[1]

def split_words(data_str)
"""
Takes a string (many lines), filters, normalizes to
lower case, scans for words, and filters the stop words.
Returns a list of pairs (word, 1), so
[(w1, 1), (w2, 1), ..., (wn, 1)]
"""
...
result = []
words = _rem_stop_words(_scan(_normalize(_filter(data_str))))
for w in words:
result.append((w, 1))
return result

def count_words(pairs_list_1, pairs_list_2)
"""
Takes two lists of pairs of the form
[(w1, 1), ...]
and returns a list of pairs [(w1, frequency), ...],
where frequency is the sum of all occurrences
"""
mapping = dict((k, v) for k, v in pairs_list_1)
for p in pairs_list_2:
if p[0] in mapping:
mapping[p[0]] += p[1]
else:
mapping[p[0]] = 1
return mapping.items()

⊳ Two key abstractions:
map(f, chunks) and
reduce(g, results)

⊳ Two key abstractions:
map(f, chunks) and
reduce(g, results)
Map-Reduce Style

STYLE #9

# Main
connection = sqlite3.connect(':memory:')
create_db_schema(connection)
load_file_into_database(sys.argv[1], connection)
# Now, let's query
c = connection.cursor()
c.execute("SELECT value, COUNT(*) as C FROM words GROUP BY value ORDER BY C DESC")
for i in range(25):
row = c.fetchone()
if row != None:
print row[0] + ' - ' + str(row[1])
connection.close()

def create_db_schema(connection):
c.execute('''CREATE TABLE documents(id PRIMARY KEY AUTOINCREMENT, name)'''
c.execute('''CREATE TABLE words(id, doc_id, value)''')
c.execute('''CREATE TABLE characters(id, word_id, value)''')
connection.commit()
c.close()

# Now let's add data to the database
# Add the document itself to the database
c.execute("INSERT INTO documents (name) VALUES (?)", (path_to_f
c.execute("SELECT id from documents WHERE name=?", (path_to_fil
doc_id = c.fetchone()[0]
# Add the words to the database
c.execute("SELECT MAX(id) FROM words")
row = c.fetchone()
word_id = row[0]
if word_id == None:
word_id = 0
for w in words:
c.execute("INSERT INTO words VALUES (?, ?, ?)", (word_id, d
# Add the characters to the database
char_id = 0
for char in w:
c.execute("INSERT INTO characters VALUES (?, ?, ?)", (c
char_id += 1
word_id += 1
connection.commit()
c.close()

⊳ Entities and relations between them
⊳ Query engine
• Declarative queries

⊳ Entities and relations between them
⊳ Query engine
• Declarative queries
Tabular Style

Take Home
⊳ Many ways of solving problems
• Know them, assess them
⊳ Constraints are important for
communication
• Make them explicit
⊳ Don’t be hostage of one way of
doing things

Ejercicios de estilo en la programación

More Related Content

What's hot (15)

Similar to Ejercicios de estilo en la programación (20)

More from Software Guru (20)

Recently uploaded (20)

Ejercicios de estilo en la programación