The long way through Software Craftsmanship

Self-Study in September 2015

Sep 1, 2015 - 9 minute read - Comments - self-study-aggregationseptember2015read195830-secondalgebraic-data-typealonzo-churchanalogyanalysisandrea-mannaanonymous-functionarm-length-recursionarticleartificial-intelligenceassumptionawsbase-casebeginnerben-whaleybig-datablue-hatbooleanboolean-parameterbootcampbrainbrowserc-plus-plusc-sharpcfa2charlie-amberclassclass-invariantclojureclojurescriptclosurecobolcodycoinductioncomparisonconnor-mendenhallcontext-free-grammarconversioncorecursioncouplingcurryingdariusz-pasciakdata-structuredata-typedesign-by-contractdeveloperdialoguedimitrios-vardoulakisdirect-recursionduck-typingeiffelelevator-testentropyeric-lippertextreme-programmingfeaturefmapformal-language-theoryfrank-rosenblattfreezerfunctorgarbage-collectiongenerative-recursiongerardo-rosselgooglehabithaskellhawk-hosthenry-bakerhigher-order-functionhiringhoare-triplethow-toideaindirect-recursioninductioninformationinstant-gratification-monkeyiterative-functionjason-friedjason-liszkajavajavascript-type-inferencejay-fieldsjeff-atwoodjim-dueyjordan-medlockjudd-keppelkleerlambda-calculuslambda-expressionlanguagelisplog4jloggingloose-couplingmachine-learningmacrostatemapmartin-fowlermartin-saliasmastermarvin-minskymaxwell-boltzmannmedian-agemethod-invariantmicroservicemicrosoft-bobmicrostatemisunderstandingmutual-recursionnbanorman-ramseyobject-orientationovenpanic-monsterpaul-grahampeceptronperlpeter-norvigpeteris-kruminsphil-calcadopostconditionpreconditionprocrastinationproductprogrammingprogramming-contestprogramming-languageprogramming-skillprologpullpushqualityqueuerational-partrecursionrecursive-caserecursive-functionrecursive-regular-expressionred-hatregular-expressionreorganizationreplretirementritika-trikharobyn-scottserviceseymour-papertshannonsimulated-annealingsix-thinking-hatssl4jsoundcloudsrpstack-overflowstacktracestandard-mlstartupstatisticsstorystrengthstrongly-typedstructural-recursionstudenttail-call-optimizationtail-recursionteam-splittech-leadthermodynamicsthinkthinking-hattim-urbantiptmuxtomasz-nurkiewicztrusttype-classtype-inferencetype-inference-algorithmtype-systemunam-mxuploadvalue-stream-mappingvideovisionweakly-typedweaknessweaponwikipediawilliam-mathesonxpyagnizen

The 30 second habit with a lifelong impact

I’ve read this article list of patterns, by Robyn Scott, in which it is explained why to compress information in a few ideas, investing 30 seconds to condense the article.

Tags: 30-second, habit, robyn-scott

The Strengths and Weaknesses of Extreme Programming

I’ve watched this video explaining the strengths and weaknesses of extreme programming. By William Matheson

Tags: extreme-programming, xp, william-matheson, video, strength, weakness

Poster de Extreme Programming

I’ve watched this video introducing eXtreme Programming. By Martín Salías

Tags: martin-salias, kleer, extreme-programming, xp

Good Tech Lead, Bad Tech Lead

I’ve read this comparison of good and bad traits in tech leads. By Jason Liszka.

Explains the differences between good and bad tech leads, even though many of these qualities are shared by plain team members

Tags: jason-liszka, tech-lead, comparison

Why Procrastinators Procrastinate

I’ve read this article by Tim Urban on procrastination: this article compares the procrastinator and the non-procrastinator brain with pictures, introducing the Rational part, the Instant Gratification Monkey and the Panic Monster. Shows some reasons why.

There is more on part 2: How to beat procrastination

Tags: tim-urban, procrastination, rational-part, instant-gratification-monkey, panic-monster, brain, comparison

Algebraic data type

I’ve read this wikipedia page, that explains what this is, a few examples and the theory behind it.

Tags: wikipedia, data-type, algebraic-data-type


I’ve read this wikipedia page, that explains the recursion basic concepts, such as:

  • induction, coinduction
  • recursion, corecursion
  • implementation details in iterative vs recursive programs:
    • shortcutting recursion (i.e., arm-length’s recursion)
    • wrapper function
    • tail-call optimization, related to tail-recursive functions
  • recursion and its relation to data structures
  • base case / recursive case and removing the need of the base one in corecursion or in non-strict languages
  • types of recursion:
    • direct, indirect, mutual
    • generative, structural

Tags: recursion, corecursion, induction, coinduction, tail-call-optimization, tail-recursion, direct-recursion, indirect-recursion, mutual-recursion, generative-recursion, structural-recursion, arm-length-recursion, iterative-function, recursive-function, base-case, recursive-case, wikipedia, data-structure

Anonymous function

I’ve read this wikipedia page, that describes what is a lambda expression or an anonymous function. How it can be used (e.g., currying, higher-order function, closures) and gives examples in many languages.

Cites its invention (Church, 1936, lambda-calculus) and its first implementation (Lisp, 1958)

Tags: alonzo-church, anonymous-function, lambda-expression, closure, lambda-calculus, lisp, currying, higher-order-function, wikipedia


I’ve read this wikipedia page, that explains the concept of closures and the usual confusion between closure and lambda. Also some applications.

Discusses closures as a way of deferring execution and implementing object-oriented (OO) systems

Tags: wikipedia, closure, object-orientation, lambda-expression

Zen Story: The Master Archer

I’ve read this story by Charlie Ambler about perfectionism and deep study, exemplified by the general that retires to study archery and the child who draws targets around the arrows.

Tags: charlie-amber, master, student, zen, story

Loosely Coupled

I’ve read this article by Ben Whaley about how to loosely couple services introducing a queue and the difference in patterns between push and pull communication.

Tags: ben-whaley, push, pull, coupling, loose-coupling, service, queue, aws

Being good at programming competitions correlates negatively with being good on the job

I’ve watched the small video and the discussion about programmers’ talent at this page. By Peteris Krumins.

The original video explains that being good at a programming contest correlates negatively with skill at a programming job, even if the company hires them.

The discussion explains the analogy with height and the NBA and concludes that this parameter should be preponderated with less importance than others.

Tags: google, peter-norvig, nba, analogy, programming-contest, programming-skill, peteris-krumins

On Functors

I’ve read this comparison by Peteris Krumins of what the functors are in different languages:

  • C++: function objects
  • Standard ML: generic implementation of interfaces. They allow to compose structures
  • Haskell: structure containing zero or more objects that can be converted to another structure containing the other objects. It’s an homomorphism between two categories.
  • Prolog: built-in predicate for self-inspection and the atom at the start of the structure

Tags: peteris-krumins, comparison, haskell, c-plus-plus, standard-ml, prolog, functor

Recursive Regular Expressions

I’ve read this article on recursive regular expressions by Peteris Krumins.

In it, he lightly describes how a regular expression relates to a Context-Free Grammar and the language support for Perl to include recursive regular expressions. Based on the examples (e.g., 0^n1^n), it really clicked to me that this could be expressed as a recursive function, with its base case and the recursive one. Also that it “depends on solutions to smaller instances of the same problem” (wikipedia)

Tags: peteris-krumins, regular-expression, recursion, recursive-regular-expression, perl, context-free-grammar, formal-language-theory

In Functional Programming, what is a functor?

I’ve read this answer, by Norman Ramsey, on what is a functor.

He explains in simple words what the concept is and how a type can belong to the class functor. Examples in haskell.

Tags: norman-ramsey, functor, stack-overflow, haskell, type-class, class, map, fmap


I’ve read this article by Jim Duey explaining functors in Clojure. He introduces a couple of notes of Haskell but all of the examples are in Clojure. Explains functors, a subset of it called applicatives, and the two libraries he has created.

Tags: jim-duey, functor, clojure, haskell

10 Tips for Proper Application Logging

I’ve read this article by Tomasz Nurkiewicz about tips on logging:

  • reduce side effects
  • use categories and levels
  • connection with external systems
  • handling exceptions
  • automatically / manually reading logging files

Tags: tomasz-nurkiewicz, logging, sl4j, log4j, tip

What is “duck typing”?

I’ve read this article by Eric Lippert about duck typing

Tags: duck-typing, eric-lippert, type-system, c-sharp


I’ve reread this article by Martin Fowler on the cost of developing features that are not needed

Tags: martin-fowler, yagni, article, misunderstanding

Learn Haskell

I’ve seen this video by Jordan Medlock on learning haskell, explaining the basics and how to use the REPL

Tags: haskell, repl, jordan-medlock, beginner, video

Learn Haskell

I’ve seen this video by Jordan Medlock on learning haskell, explaining the basics and how to use the REPL

Tags: haskell, repl, jordan-medlock, beginner, video

TMUX - The Terminal Multiplexer

I’ve read these two parts: (one, two) of an introduction guide to tmux (the unix terminal multiplexer) by Cody from Hawk Host.

In it, he explains the basics of tmux and the main differences with screen

Tags: cody, hawk-host, tmux, how-to

Thermodynamics and Garbage Collection

I’ve read this paper by Henry G. Baker that explains the analogy of the garbage collection (“a freezer”) and thermodynamics, where the state mutator (th program, also an oven) modifies the garbage heap and introduces / extracts entropy into the system.

Comparison between entropy and lack of information, using the theories from Shannon, Maxwell-Boltzmann. There’s a reference to the knapsack problem and to simulated annealing.

There’s also a gentle introduction to thermodynamics in layman terms: heat, temperature, microstates, macrostates, reversability, etc.

In this paper it is also reflected (in macro vs micro states) that the sum all parts is simpler than the single ones (i.e., Information Hiding)

Tags: henry-baker, thermodynamics, microstate, macrostate, analogy, simulated-annealing, garbage-collection, shannon, information, maxwell-boltzmann, freezer, oven, entropy

How we ended up with microservices

I’ve read this article, by Phil Calçado, where he talks about his stay at SoundCloud:

  • the value stream map: from X days to Y
  • reorganizing teams into service teams
  • conway’s law and teams being responsible for support. Also, being given full authority

Tags: phil-calcado, soundcloud, microservice, team-split, value-stream-mapping, conversion, reorganization

Lisp is still a secret weapon

I’ve read this article by Judd Keppel where he explains it is a good idea that Clojure / ClojureScript continues to be a secret, not known among developers. Cites the article ‘Beating the averages’ by Paul Graham and the amount of available packages in npm, maven central, etc

Tags: paul-graham, judd-keppel, clojure, clojurescript, weapon, developer


I’ve read this wikipedia article that explains the single-layer and multi-layer perceptron. First designed to be a machine (hardware), but later an algorithm for supervised machine learning. Worked by Minsky & Papert and invented by Frank Rosenblatt in 1958.

Tags: peceptron, artificial-intelligence, machine-learning, frank-rosenblatt, 1958, marvin-minsky, seymour-papert

Is C# a strongly typed or a weakly typed language?

I’ve read this article, in the form of a dialogue between Eric Lippert and himself about the C# language and its type system.

Tags: type-system, c-sharp, eric-lippert, dialogue, strongly-typed, weakly-typed, language

Diseño por contratos: construyendo software confiable

I’ve read this paper that explains design by contract, based on the Hoare triplet, pre-post condition, method and class invariant. With examples in Eiffel, Java about a package sender company. Also explains pre/post with inheritance. By Gerardo Rossel and Andrea Manna. In Spanish.

Tags: gerardo-rossel, andrea-manna, design-by-contract, unam-mx, eiffel, java, precondition, postcondition, trust, quality, hoare-triplet, method-invariant, class-invariant

The Inevitable Return of COBOL

I’ve read this article that explains the current state of COBOL in programming and systems. Written by Ritika Trikha

Tags: ritika-trikha, cobol, programming-language, retirement, median-age

The Risky Eclipse of Statisticians

I’ve read this article where Ritika Trikha explains the current situation regarding Big Data and the statiscian jobs. How Big Data is in demand but the latter are not and what effects this might have.

Tags: ritika-trikha, bootcamp, programming, hiring, big-data, analysis, statistics

Give it five minutes

I’ve read this article by Jason Fried where he explains why we should give ideas time to sink in and marinate, before dismissing them. Ideas are so fragile that it is better to let them live for a while before dismissing them. This also applies for thoughts (other people’s or your own).

Tags: jason-fried, idea, think, startup, blue-hat, thinking-hat, six-thinking-hats, red-hat

Reading Clojure Stacktraces

I’ve read this article by Jay Fields on reading clojure stacktraces. Very similar to “Clojure Stack Traces for the Uninitiated”

Tags: jay-fields, clojure, stacktrace

Clojure Stack Traces for the Uninitiated

I’ve read this article on how to interpret clojure stacktraces. Written by Connor Mendenhall

Tags: connor-mendenhall, clojure, stacktrace

JavaScript type inference

I’ve found (and played) with this JavaScript type inference engine. Written in Javascript (and available online). Written by Dimitrios Vardoulakis.

Tags: javascript-type-inference, type-inference, type-inference-algorithm, dimitrios-vardoulakis, cfa2

Alternatives to boolean parameters

I’ve read this article explaining alternatives to sending a boolean parameter to decide on the contents of the function. Written by Dariusz Pasciak

As I heard some time ago, if a function receives a boolean to decide on what to do, it will for sure have more than one responsibility: one for the false value and one for the true value.

Tags: dariusz-pasciak, boolean, srp, boolean-parameter

Why Are Web Uploads So Painful?

I’ve read this article on web uploads being painful. By Jeff Atwood. The screenshots feel old (2007) and some of the problems have already been solved.

Tags: jeff-atwood, article, upload, browser

Can Your Team Pass The Elevator Test?

I’ve read this article on the elevator test by Jeff Atwood.

Tags: jeff-atwood, article, elevator-test, assumption, microsoft-bob, vision, product, feature

Coding dojo: Palindromes Brown-bag session: eXtreme Programming

comments powered by Disqus