The long way through Software Craftsmanship

Self-study in May 2015

May 9, 2015 - 5 minute read - Comments - 2010articlepassioncraftsmanshipbootcamptalkvideoslidesvideoosconvalueslanguageluke-sneeringerrob-pikeken-auerbufferself-study-aggregationfunctional-programmingguideoopslascrum2004jmockgoosnat-prycesteve-freemankatadojodtodomain-objectcoding-dojostuart-hallowayhaskelllisplearningtiago-garciajeremy-jarrellgregory-moecksaron-yitbarekgreg-wilsonron-jeffriescarlos-blejeff-atwoodslava-akhmechetgodavid-pollakmichael-bernsteinhornbecktechnologistwell-roundedpaperlisp-1lisp-2tedxtedx-brusselsaza-raskindata-bankscience-corpphilippe-creuxpreparatory-refactoringrefactoringadam-angelomanagementengineeringreadingself-study

Update: I’ve grouped all small posts related to the self-study from May 2015 into a single post

Programmer passion considered harmful

I’ve read this article on why programmer passion could be negative. The title is similar to a paper by Dijkstra.

Software Craftsmanship: Are Bootcamps Enough?

I’ve read this article on software craftsmanship, development bootcamps and passion by Ken Auer

Improve your development environments with virtualization

I have seen this video: Improve your development environments with virtualization by Luke Sneeringer.

My notes:

  • development should be exactly like production.
  • except where it is too painful. there it should be different

Buffer’s take on values

I have found these values, written by Buffer, very interesting.

Public static void

I’ve watched this video: “Public, static void” by Rob Pike. The slides can be found here

My notes

  • too much bureaucracy
  • fighting the compiler
  • dynamic vs static typing
  • language too verbose
  • do not mix the two of them

  • a language niche:

    • comprehensible
    • statically typed
    • light on the page
    • fast to work in
    • scales well
    • doesn’t require tools but supports them well
    • good at networking and multiprocessing

(minute 10:09)​

  • Go was born to fill this niche

Nothing is something

This video has been extracted to a post of its own.

Software is eating the world

This video has been extracted to a post of its own.

The Cost of Test Driven Development

I’ve read this article, on the cost of doing TDD, which refers to this paper: Realizing quality improvement through test driven development: results and experiences of four industrial teams (below)

Realizing quality improvement through test driven development: results and experiences of four industrial teams

This paper has been extracted to a post of its own.

Learn You Some Lisp for Great Good

I’ve watched the video Learn You Some Lisp for Great Good, by Howard Abrams.

I guess this is a reference to the popular Learn You a Haskell for Great Good!.

He suggests many interesting resources for learning Lisp dialects. The live coding is in Clojure:

On another topic, in the Bank accounts exercise from Exercism meetup, we discussed the book Programming Clojure (2nd edition) by Stuart Halloway

Professor Frisby’s Mostly Adequate Guide to Functional Programming

I’ve read this guide to functional programming. It is still work in progress (WIP) but still interesting. Written in javascript, so you can REPL in the browser.

Learning Code Good

I’ve watched this video, by Saron Yitbarek: Learn Code Good.

Why You Don’t Get Mock Objects

I’ve watched Why You Don’t Get Mock Objects, by Gregory Moeck.

In it, they point to the Growing Object-Oriented Software Guided by Tests book (category here), the paper Mock Roles, not Objects (also present in the GOOS book).

Technical Debt: A Repayment Plan

I’ve read this article by Jeremy Jarrell on technical debt how to repay it: schedule, taxes, default, etc

This has made me think of the “Deuda técnica, origen y consecuencias” talk (Technical debt: origin and consequences) (Spanish), that was delivered by Javier Gómez at the Software Craftsmanship 2014.

Revisiting XP: be a thoughtful programmer by exercising more collective ownership

I’ve read this article by Tiago Garcia on the collective code ownership, as stated by Xtreme Programming (XP), with some example and guidelines.

Where’s the Real Bottleneck in Scientific Computing?

I’ve read this article by Greg Wilson on the tools and procedures investigators use to produce software.

Testing inside the Sprint

I’ve read this article by Ron Jeffries.

Discusses the need for testing and why this hasn’t been communicated enough, as there still are people who have not understood it.

Also about why people equal something failing when using scrum with scrum failing.

DTO vs Domain Models

I’ve read this article by Carlos Blé

Homoiconicity isn’t the point

I’ve read this article by David Herman about homoiconicity, comparing Lisp dialects (have it) to others that don’t. The main point is at the end, where it says:

[…] homoiconicity isn’t the point, read is

So You Don’t Want to be a Programmer After All

I’ve read this article by Jeff Atwood. Cites the golden handcuffs (also known as golden shackles), reasons to be and not to be a programmer, and how to be an average and outstanding programmer

The Nature of Lisp

I’ve read this article / introduction to Lisp by Slava Akhmechet

[David Pollak’s] My Thoughts on Go

I’ve read these comments on Go Lang from David Pollak

The Well-Rounded Technologist

I’ve read this article by Michael Bernstein

Should I read papers?

I’ve read this article by Michael Bernstein

Lisp-1 vs Lisp-2

I’ve read this article by @Hornbeck about the lisp 1 and lisp 2.

Science Corps

I’ve watched this TEDx talk by Aza Raskin, featuring Data Banks and Science corps

Healthy Codebase and Preparatory Refactoring

I’ve read this article by Philippe Creux about preparatory refactoring

You Are Learning Haskell Right Now (Or Anything You Want Really)

I’ve read this article by Michael Bernstein

Lisp is Abstract Syntax

I’ve read this article by Michael Bernstein

Two Things Types Have Taught Me

I’ve read this article by Michael Bernstein

Don’t Bet Against Yourself

I’ve read this article by Michael Bernstein

Learning Math: A Blank Is A Blank With A Blank

I’ve read this article by Michael Bernstein

The False Economy Of Metaprogramming

I’ve read this article by Michael Bernstein

Management and Engineering, overlapping

I’ve read this Quora answer by Adam D’Angelo. The original title is: Does Adam D’Angelo feel comfortable with the transition from an engineer to a management position?

Evolution of The Twitter Stack

I’ve read these slides about changing the technology stack in Twitter: from Rails to JVM-based

Compilers as Assistants

I’ve read this article by Evan Czaplicki on seeing the compiler as an assistant to your work, instead of an adversary. Of how the compiler should give the most useful errors and warnings.

He also explains what features have been removed from the Elm language in 0.16.

Tags: compiler, assistant, adversary, enemy, elm, elm-compiler, evan-czaplicki

What versus How Talk: Software is eating the world

comments powered by Disqus