# Robert C. Martin

Published articles for Robert C. Martin.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Functional Classes in Clojure

DevFeed: [Functional Classes in Clojure](<https://devfeed.tech/articles/functional-classes-in-clojure-21800.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2023/01/19/functional-classes-clojure.html>)

Published: 2023-01-19T00:00:00Z

Content type: article

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

The article explains how class-like abstractions can be implemented in functional programming using Clojure. It presents a Dilithium Cloud example built from named functions, an internally defined data structure, dynamic type specifications, constructors, methods, and unit-test validation, while arguing that class syntax, inheritance, and polymorphic dispatch are not required.

### Source excerpt

My previous blog seemed only to continue the confusion regarding classes in Functional Programming. Indeed, many people got quite irate. So perhaps a bit of code will help. Trigger Warning: Object Oriented Terminology. Dynamically Typed Language. Mixed Metaphors. Distracting Animations. To all the adherents of the Statically Typed Functional Programming religion: I know that you believe that Static Typing is an essential aspect of Functional Programming and that no mere dynamically typed language could ever begin to approach the heights and glory of The One True and Holy TYPED Functional Apotheotic Paradigm. But we lowly programmers quivering down here at the base of Orthanc can only hope to meekly subsist on the dregs that fall from on high. (R.I.P. Kirstie Alley OK, so, once again... A class is an intentionally named abstraction that consists of a set of narrowly cohesive functions that operate over an internally defined data structure. We do not need the class keyword. Nor do we need polymorphic dispatch. Nor do we need inheritance. A class is just a description, whether in full or in part, of an object. For example - it's time we talked about clouds (which I have looked at from both sides now; and do, in fact, understand pretty well). So... Here come your father's parentheses! (ns spacewar.game-logic.clouds (:require [clojure.spec.alpha :as s] [spacewar.geometry :as geo] [spacewar.game-logic.config :as glc])) (s/def ::x number?) (s/def ::y number?) (s/def ::concentration number?) (s/def ::cloud (s/keys :req-un [::x ::y ::concentration])) (s/def ::clouds (s/coll-of ::cloud)) (defn valid-cloud? [cloud] (let [valid (s/valid? ::cloud cloud)] (when (not valid) (println (s/explain-str ::cloud cloud))) valid)) (defn make-cloud ([] (make-cloud 0 0 0)) ([x y concentration] {:x x :y y :concentration concentration})) (defn harvest-dilithium [ms ship cloud] (let [ship-pos [(:x ship) (:y ship)] cloud-pos [(:x cloud) (:y cloud)]] (if (< (geo/distance ship-pos cloud-pos) glc/dilit

## Functional Classes

DevFeed: [Functional Classes](<https://devfeed.tech/articles/functional-classes-21799.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2023/01/18/functional-classes.html>)

Published: 2023-01-18T00:00:00Z

Content type: article

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [C#](<https://devfeed.tech/topics/csharp.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [java](<https://devfeed.tech/tags/java.md>)

### AI overview

The article argues that functional programs can and should be organized into classes, even when they use immutable data structures. It defines a class as a cohesive group of narrowly focused functions operating on encapsulated data, and examines how abstraction and classification shaped object-oriented languages.

### Source excerpt

I recently tweeted the following: Should you subdivide a functional program into classes the way you would an object oriented program? Yes. You should. Because the rules don't change just because you've chosen to use immutable data structures. -- Uncle Bob Martin (@unclebobmartin) January 17, 2023 This led to a bevy of interesting responses about the difference between classes and modules. In answer to those responses I tweeted this: A class is a group of cohesive and narrowly defined functions that operate on an encapsulated data structure. The functions may, or may not, be polymorphically deployed. -- Uncle Bob Martin (@unclebobmartin) January 17, 2023 Of course that only led to an increased number of interesting responses. And so I thought that it might be wise to blog about my reasoning rather than to continue trying to cram that reasoning into tweets. If you are in doubt about what FP is, and about what OO is, and about whether the two are compatible, then I recommend this old blog of mine. What is a class? According to the dictionary a class is: A set, collection, group, or configuration containing members regarded as having certain attributes or traits in common; a kind or category. Now consider that definition when reading the next paragraph. In OO languages we organize our programs into classes of objects that share similar traits. We describe those objects in terms of the attributes and behaviors that they have in common. We strive to create hierarchies of classification that those objects can fit within. We consider the higher level classifications to be abstractions that allow the expression of general truths that are independent of irrelevant details. (Indeed, I once defined abstraction as: The Amplification of the essential, and the elimination of the irrelevant.[1]) In 1966 the power of abstraction by classification led the authors of Simula to create the keyword class. In 1980, Bjarne Stroustrup continued that convention and used the class keyword in C

## Space War

DevFeed: [Space War](<https://devfeed.tech/articles/space-war-21798.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/11/28/Spacewar.html>)

Published: 2021-11-28T00:00:00Z

Content type: article

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [GUI](<https://devfeed.tech/topics/gui.md>), [Code](<https://devfeed.tech/topics/code.md>), [Framework](<https://devfeed.tech/topics/framework.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [gui](<https://devfeed.tech/tags/gui.md>), [programming](<https://devfeed.tech/tags/programming.md>), [project](<https://devfeed.tech/tags/project.md>), [space](<https://devfeed.tech/tags/space.md>)

### AI overview

The article describes the author's return to Space War, a game first written in 1978 and revisited in a newer version started in 2018. The newer system is an animated, GUI-driven application written entirely in Clojure, using Quil as a shim for the Processing GUI framework. The author discusses how functional design, organization, and extensive tests made the codebase easy to understand after several years.

### Source excerpt

For the last month I've been spending a lot of time working on Space War. I know, I know, I should have been working on Clean Code Episode 67: Legacy Code, and Euler 5, and Countest and Curmugeon 3. I should have been working on a blog, or a new book, or... But I couldn't let go of Space War. It kept calling me. The first time I wrote Space War was in 1978. I wrote it in Alcom, which was a simple derivative of Focal, which was an analog of Basic for the PDP-8. The computer was an M365 which was an augmented version of a PDP-8 and was proprietery to Teradyne, my employer at the time. The UI was screen based, using character graphics, similar to curses. Screen updates took on the order of a second. All input was through the keyboard. We used to play it on one machine while waiting for a compile on another. Forty years later, in September of 2018, I started working on this version of Space War. It's an animated GUI driven system with a frame rate of 30fps. It is written entirely in Clojure and uses the Quil shim for the Processing GUI framework. My justification for writing it was so that I could use it as the case study for my cleancoders.com videos on Functional Programming. Once that series of videos was complete, I set Space War aside and started working on other things. Then, a month ago, the program called to me. I don't know why. Perhaps it was because I'd left it in a partially completed state. Perhaps it was because I had just finished Clean Craftsmanship and I needed a way to decompress. Or, perhaps it was just because I felt like it. Whatever the reason, I loaded up the project and started goofing around with it. Now I'm sure you've had that feeling of trepidation when you pick up a code base that you haven't seen in three years. I certainly felt it. I mean, what was I going to find in there? Would I be able to get my bearings and understand the code? Or would I flail around aimlessly for weeks? I needn't have worried. The code base was nicely organized. The

## Functional Duplications

DevFeed: [Functional Duplications](<https://devfeed.tech/articles/functional-duplications-21797.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/10/28/functional-duplication.html>)

Published: 2021-10-28T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [bug](<https://devfeed.tech/topics/bug.md>), [debug](<https://devfeed.tech/topics/debug.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [test-coverage](<https://devfeed.tech/topics/test-coverage.md>), [Randomizer](<https://devfeed.tech/topics/randomizer.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [random](<https://devfeed.tech/tags/random.md>), [tdd](<https://devfeed.tech/tags/tdd.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>)

### AI overview

The article describes debugging a crash in a Space War game after randomly placed bases were duplicated at the same location. Despite using TDD and having test coverage, the defect appeared during gameplay and was traced by adding runtime checks until the responsible low-frequency function was found.

### Source excerpt

I broke out my old Space War game a few days ago and decided to make a few changes to speed the game up and make it more fun to play. In so doing I discovered a very interesting bug. One of the changes I made was to populate the initial space with a few random bases scattered here and there. This would allow the player some extra resources with which to battle the Klingons while building up a network of more bases. While I was playing the modified game, it crashed. Hard. Now I wrote this with TDD, and I was very disciplined about the cleanliness of the code, and the test coverage. So this was unexpected. So I dug up all my old debugging skills from the pit in which I had buried them, and started to work out what was going on. It wasn't long before I realized that crash was occuring because a transport was being launched between two bases, but the angle of the velocity vector of the transport was :bad-angle. This can only happen if the two bases exist at the exact same location. Bases don't move around in this game, so there's no chance that two bases will accidentally slide on top of each other. There is a very (very) minor chance that the random number generator will put two bases on top of each other at the start of the game; but the odds are so miniscule that didn't worry about it. In any case, this crash happened well into the game I was playing, so initial values could not have been the cause. Fortunately it's pretty easy to hunt and peck around in the game, so I was quickly able to discover that the two bases in question were duplicates of each other. Something in my code was duplicating bases! Well now that should't be too hard to find. So I wrote a litte function that would examine the world and halt with a message if the world contained two bases at the same location. I called this function in the main update loop, and sure enough after 20 minutes of play the program halted with my message. Unfortunately being able to detect that the duplication occurred di

## A PDP-8 Emulator Revisited on the iPad

DevFeed: [A PDP-8 Emulator Revisited on the iPad](<https://devfeed.tech/articles/roots-21796.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/09/25/roots.html>)

Published: 2021-09-25T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Emulator](<https://devfeed.tech/topics/emulator.md>), [Lua](<https://devfeed.tech/topics/lua.md>), [Code](<https://devfeed.tech/topics/code.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [code](<https://devfeed.tech/tags/code.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [github](<https://devfeed.tech/tags/github.md>), [lua](<https://devfeed.tech/tags/lua.md>)

### AI overview

The author recounts building a PDP-8 emulator in Codea on an iPad, losing access to it after Apple restricted source-code sharing, and later restoring and updating it from GitHub.

### Source excerpt

When I was 15 or so, my father would drive me, and my best friend, Tim Conrad, to the Digital Equipment Corporation (DEC) sales office each Saturday. This was a 30 min drive. My father would drop us off in the morning and pick us up in the late afternoon. He spend two hours in his car each Saturday hauling us around. Thanks Dad! Tim and I would spend our day "playing" with the floor model of the PDP-8 they had at the office. The office staff were very accommodating and accepting of our presence, and they helped us out if we needed any fresh rolls of teleprinter paper, or paper tape. Several years later, at the age of 20, I found myself working at Teradyne Applied Systems in Chicago. The computer we used there was called an M365; but it was really just an upgraded PDP-8. We used it to control lasers in order to trim electronic components to very precise values. Forty four years later, in May of 2015, I started playing with a cute little Lua environment on my iPad called Codea. I wrote several fun little programs, like lunar lander, etc. But then I thought: "Wouldn't it be fun to write a PDP-8 Emulator?" A few days/weeks later I had a nice little PDP-8 emulator running on my iPad. I found some archived binary images of ancient paper tapes and managed to load them into my emulator. This allowed me to run the suite of development tools that I had used back in those early days. Then Apple decided it didn't want people writing code on the Ipad that was not distributed through the App store, so they blocked the means by which Codea users could share source code. Indeed, I couldn't even move Lua source code to my new iPads. So the emulator was lost. Fortunately I had put the last working version up on GitHub. At some point, Apple reopened the channel, perhaps due to a court case. I discovered this a few weeks back, and loaded that old source code back into my iPad. It worked like a champ. I made a few changes to deal with the bigger screen, and the faster processor, and the

## More On Types

DevFeed: [More On Types](<https://devfeed.tech/articles/more-on-types-21795.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/06/29/MoreOnTypes.html>)

Published: 2021-06-29T00:00:00Z

Content type: article

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>), [Framework](<https://devfeed.tech/topics/framework.md>), [GUI](<https://devfeed.tech/topics/gui.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [framework](<https://devfeed.tech/tags/framework.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [programming](<https://devfeed.tech/tags/programming.md>), [state](<https://devfeed.tech/tags/state.md>), [types](<https://devfeed.tech/tags/types.md>), [velocity](<https://devfeed.tech/tags/velocity.md>)

### AI overview

The article presents a turtle graphics program written in Clojure and explores the type model of its turtle object using clojure/spec. It describes the turtle's geometric and animation-related state, including position, heading, velocity, distance, angular velocity, pen state, and related constraints.

### Source excerpt

Recently I wrote a cute little program for doing Turtle Graphics. For those of you who don't know, turtle graphics were originally added to the LOGO language by Seymour Papert in the late 1960s. He built a robot that he called a "turtle" that could hold a pen. The robot had wheels and could move forwards and backwards, and could rotate left and right. It could also raise and lower the pen. When placed on a sheet of paper, the turtle could be commanded to draw interesting designs. Papert's goal was to teach children about programming. As the years went by the robot got replaced with screens, and the turtle became an icon that could draw lines. Children from the 70s until now have been enthralled by the simple commands for directing the turtle, and the elegant drawings they can make. For example, this is how you might draw a square: forward 100 right 90 forward 100 right 90 forward 100 right 90 forward 100 right 90. Recently I had a need to explore some interesting geometrical designs. Turtle graphics would be perfect for my purposes. So I wrote a turtle graphics processor in Clojure. [code] I used the quil framework which is based on the Processing framework in Java. This framework makes it very easy to create simple GUIs in Clojure. Now consider the problem of the Turtle. What is the type model for this object? What fields does it have, and what constraints must be placed on those fields? Here was my solution to that problem, written in clojure/spec. As usual, in Clojure, you start at the bottom and read towards the top. (s/def ::position (s/tuple number? number?)) (s/def ::heading (s/and number? #(<= 0 % 360))) (s/def ::velocity number?) (s/def ::distance number?) (s/def ::omega number?) (s/def ::angle number?) (s/def ::weight (s/and pos? number?)) (s/def ::state #{:idle :busy}) (s/def ::pen #{:up :down}) (s/def ::pen-start (s/or :nil nil? :pos (s/tuple number? number?))) (s/def ::line-start (s/tuple number? number?)) (s/def ::line-end (s/tuple number? number?)) (s

## On Types

DevFeed: [On Types](<https://devfeed.tech/articles/on-types-21794.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/06/25/OnTypes.html>)

Published: 2021-06-25T00:00:00Z

Content type: article

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Assembly](<https://devfeed.tech/topics/assembly.md>), [Finite-state machine](<https://devfeed.tech/topics/finite-state-machine.md>), [IO](<https://devfeed.tech/topics/io.md>), [Operating system](<https://devfeed.tech/topics/operating-system.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [ibm](<https://devfeed.tech/tags/ibm.md>), [io](<https://devfeed.tech/tags/io.md>), [memory](<https://devfeed.tech/tags/memory.md>), [program](<https://devfeed.tech/tags/program.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

An autobiographical account of early programming experiences from 1964 through the early 1970s, covering finite-state machines, binary machine language, assembly programming, magnetic-tape record processing, and programming on systems with limited memory and no operating system.

### Source excerpt

I wrote my first program in 1964. The name of the program was: Mr Patternson's Computerized Gate, and it was implemented on a little plastic computer named DIGICOMP-I, which was a cute little three bit finite state machine with 6 AND gates. The first electronic computer I ever wrote a program for was an ECP-18 in 1966. This was a 15 bit wide machine with 1024 words of drum memory. The programs I wrote were all in binary machine language and were entered through the front-panel switches. In the years between 1967 and 1969 my father would drive my friend, Tim Conrad, and I 25 miles to the Digital Equipment Corp sales office, where we would spend our Saturdays entering programs into the PDP-8 that they had on the floor. They were very gracious to allow us such access and freedom. The code we wrote was in PAL-D assembler (which was written by Ed Yourdon when he was 21 years old). My very first job as a programmer was temporary. A matter of two weeks. I was 17, and the year was 1969. My father went to the CEO of a nearby insurance actuarial firm, ASC Tabulating, and in his inimitable fashion, told them that they would be hiring me for a summer job. He had a way of being very convincing. The program I wrote for ASC was named IDSET. It was written in Honeywell H200 assembler (the language was called Easycoder and was based on IBM 1401 Autocoder). The purpose was to read student records from a magnetic tape and insert ID codes into those records, and then write them out onto a new tape. With some coaching, I was able to get that program to work. Upon graduating High School, in 1971, I got a job at ASC again; but this time as a third-shift off-line printer operator. We were printing junk mail, which was a brand new thing back then. A few months later I was hired as a full-time programmer analyst at ASC, and was assigned to work on huge re-write of a massive accounting and records system for Local 705 Trucker's union in Chicago. The existing system ran on a great big GE Datan

## if-else-switch

DevFeed: [if-else-switch](<https://devfeed.tech/articles/if-else-switch-21793.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/03/06/ifElseSwitch.html>)

Published: 2021-03-06T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>), [Software](<https://devfeed.tech/topics/software.md>), [systems](<https://devfeed.tech/topics/systems.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [software](<https://devfeed.tech/tags/software.md>), [source](<https://devfeed.tech/tags/source.md>), [structure](<https://devfeed.tech/tags/structure.md>)

### AI overview

The article argues that repeated if/else or switch statements create fragile systems and tangled dependencies. It recommends isolating the conditional logic in a factory and using polymorphic objects to break dependencies on lower-level modules, supporting more flexible component-based architectures.

### Source excerpt

A few days ago someone tweeted a question asking which of the following PHP snippets was better than the others, or whether there might be an even better approach. I tweeted my answer in the following cryptic paragraph. Place the if/else cases in a factory object that creates a polymorphic object for each variant. Create the factory in 'main' and pass it into your app. That will ensure that the if/else chain occurs only once. Others have since asked me for an example. Twitter is not the best medium for that so... Firstly, if the sole intent of the programmer is to translate: 0->'male', 1->'female' otherwise -> 'unknown' ...then his refactoring #2 would be my preference. However, I have a hard time believing that the business rules of the system are not using that gender code for making policy decisions. My fear is that the if/else/switch chain that the author was asking about is replicated in many more places within the code. Some of those if/else/switch statements might switch on the integer, and others might switch on the string. It's not inconceivable that you'd find a if/else/switch that used an integer in one case and a string in the next! The proliferation of if/else/switch statements is a common problem in software systems. The fact that they are replicated in many places is problematic because when such statements are inevitably changed, it is easy to miss some. This leads to fragile systems. But there is a worse problem with if/else/switch statements. It's the dependency structure. Such statements tend to have cases that point outwards towards lower level modules. This often means that the module containing the if/else/switch will have source code dependencies upon those lower level modules. That's bad enough. We don't like dependencies that run from high level modules to low level modules. They thwart our desire to create architectures that are made up of independently deployable components. However, the above diagram shows that it's worse than that. Other hig

## Pairing Guidelines

DevFeed: [Pairing Guidelines](<https://devfeed.tech/articles/pairing-guidelines-21792.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2021/01/17/Pairing.html>)

Published: 2021-01-17T00:00:00Z

Content type: article

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [pairs](<https://devfeed.tech/tags/pairs.md>), [programming](<https://devfeed.tech/tags/programming.md>), [projects](<https://devfeed.tech/tags/projects.md>), [team](<https://devfeed.tech/tags/team.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The article presents practical guidelines for pair programming. Pairing is most valuable for non-trivial but not deeply difficult programming work, while very deep problems may require concentration and trivial tasks usually do not justify pairing. It recommends voluntary, informal, short sessions and emphasizes balancing collaboration with individual work and team familiarity.

### Source excerpt

Everybody pairs from time to time. It is a rare programmer who has not sat down with another programmer to look something over or help find a bug. Deep problems, that require much heavy thinking, do not often lend themselves to pairing. The interaction between the programmers tends to disrupt the necessary concentration. On the other hand, it is not uncommon for programmers to get caught in a problem that they think is deep, but for which there is a much simpler solution that another programmer could quickly see. So it is wise to start deep problems with a pair, or even a mob, but then break it up when it becomes clear that the problem is irreducible. On the other side of the spectrum, there is no good reason to pair on trivial matters. Fleshing out a list of error messages, or loading fifty fields into a form are relatively mindless activities that do not require the scrutiny afforded by pairing. Then there is the vast middle. This is where pairing/mobbing are most valuable. These are problems that are non-trivial, but also not particularly deep. This is 90% of all programming. Pairing on this type of code keeps that code well tested, well structured, and as simple as possible. Pairing should always be voluntary, never be forced, never be scheduled by a manager, and never tracked. It is an informal process that is entirely under the control of the individual programmers. Some people can't, or won't do it. That's ok; but it may require that their participation in certain projects be curtailed. Pairing sessions should be short-ish. 20-40 minutes at a time. (Tomato sized) With no more than three or four consecutive sessions of that length. This is not a rule, just an informal guideline. Not all code that would benefit from pairing, should be written by pairs. A mature team might pair 50% of the time, or even less. During the pairing sessions, a large amount of code will be reviewed; far more than the pair is actively writing; and thus the benefits of pairing will be s

## Solid Relevance

DevFeed: [Solid Relevance](<https://devfeed.tech/articles/solid-relevance-21791.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Relevance.html>)

Published: 2020-10-18T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Code](<https://devfeed.tech/topics/code.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Polymorphism](<https://devfeed.tech/topics/polymorphism.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [gui](<https://devfeed.tech/tags/gui.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

The article argues that the SOLID principles remain relevant despite modern development practices such as microservices and reduced reliance on inheritance. It explains that software fundamentals have changed little and illustrates the Single Responsibility Principle by separating business rules, GUI code, SQL queries, communications protocols, and independently changing modules. The supplied text ends partway through the discussion.

### Source excerpt

Recently I received a letter from someone with a concern. It went like this: For years the knowledge of the SOLID principle has been a standard part of our recruiting procedure. Candidates were expected to have a good working knowledge of these principles. Lately, however, one of our managers, who doesn't code much anymore, has questioned whether that is wise. His points were that the Open-Closed principle isn't very important anymore because most of the code we write isn't contained in large monoliths and making changes to small microservices is safe and easy. The Liskov Substitution Principle is long out of date because we don't focus on inheritance nearly as much as we did 20 years ago. I think we should consider Dan North's position on SOLID - "Just write simple code." I wrote the following letter in response: The SOLID principles remain as relevant to day as they were in the 90s (and indeed before that). This is because software hasn't changed all that much in all those years -- and that is because software hasn't change all that much since 1945 when Turing wrote the first lines of code for an electronic computer. Software is still if statements, while loops, and assignment statements -- Sequence, Selection, and Iteration. Every new generation likes to think that their world is vastly different from the generation before. Every new generation is wrong about that; which is something that every new generation learns once the next new generation comes along to tell them how much everything has changed. <grin> So let's walk through the principles, one by one. SRP) The Single Responsibility Principle. Gather together the things that change for the same reasons. Separate things that change for different reasons. It is hard to imagine that this principle is not relevant in software. We do not mix business rules with GUI code. We do not mix SQL queries with communications protocols. We keep code that is changed for different reasons separate so that changes to one part t

## Transforming Nested Loops into a Single Loop with State

DevFeed: [Transforming Nested Loops into a Single Loop with State](<https://devfeed.tech/articles/loopy-21790.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2020/09/30/loopy.html>)

Published: 2020-09-30T00:00:00Z

Content type: tutorial

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Finite-state machine](<https://devfeed.tech/topics/finite-state-machine.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [flow](<https://devfeed.tech/tags/flow.md>), [go](<https://devfeed.tech/tags/go.md>), [i](<https://devfeed.tech/tags/i.md>), [journey](<https://devfeed.tech/tags/journey.md>), [loops](<https://devfeed.tech/tags/loops.md>), [machine](<https://devfeed.tech/tags/machine.md>), [model](<https://devfeed.tech/tags/model.md>), [state](<https://devfeed.tech/tags/state.md>)

### AI overview

This article compares the standard Java solution to the Prime Factors Kata with a Clojure implementation using a single recursive loop. It then shows how nested-loop behavior can be represented with state and transformed into a single loop, culminating in a Moore model finite-state machine.

### Source excerpt

The following is a segment of a journey. It has no obvious beginning point, nor does it actually end up anywhere. The value, if any, is in the journey itself. The code below is the standard solution to the Prime Factors Kata. public List<Integer> factorsOf(int n) { ArrayList<Integer> factors = new ArrayList<>(); for (int d = 2; n > 1; d++) for (; n % d == 0; n /= d) factors.add(d); return factors; } However, I was doing this kata in Clojure the other day and I wound up with a different solution. It looked like this: (defn prime-factors [n] (loop [n n d 2 factors []] (if (> n 1) (if (zero? (mod n d)) (recur (/ n d) d (conj factors d)) (recur n (inc d) factors)) factors))) The algorithm is pretty much the same. I mean if you tracked the value of n, d, and factors they would go through the same changes. On the other hand the code in Java is a doubly nested loop; but the code in Clojure is a single recursive loop with two recursion points. That's interesting. I could write the recursive algorithm in Java like this: private List<Integer> factorsOf(int n) { return factorsOf(n, 2, new ArrayList<Integer>()); } private List<Integer> factorsOf(int n, int d, List<Integer> factors) { if (n>1) { if (n%d == 0) { factors.add(d); return factorsOf(n/d, d, factors); } else { return factorsOf(n, d+1, factors); } } return factors; } And then, since this is tail recursive, I could rewrite it as a straight loop. private List<Integer> factorsOf(int n, int d, List<Integer> factors) { while (true) { if (n > 1) { if (n % d == 0) { factors.add(d); n /= d; } else { d++; } } else return factors; } } For all intents and purposes this code executes the same algorithm as the standard solution; but it does not have a doubly nested loop. We have transformed the code from a doubly nested loop, to a single loop, without affecting the algorithm. Is this always possible? In other words: given a program with a nested loop, is there a way to write the same program with a single loop? The answer to that is

## Conference Conduct

DevFeed: [Conference Conduct](<https://devfeed.tech/articles/conference-conduct-21789.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2020/09/23/ConferenceConduct.html>)

Published: 2020-09-23T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [code-of-conduct](<https://devfeed.tech/tags/code-of-conduct.md>), [conference](<https://devfeed.tech/tags/conference.md>), [conferences](<https://devfeed.tech/tags/conferences.md>), [identity](<https://devfeed.tech/tags/identity.md>), [speakers](<https://devfeed.tech/tags/speakers.md>)

### AI overview

The article argues that software conference codes of conduct should not be weaponized to exclude people. It calls for transparent adjudication processes that give accused attendees and speakers notice, an opportunity to defend themselves, and knowledge of their accusers' identities.

### Source excerpt

It was just a few years ago, at the height of the Me Too revelations, that codes of conduct began to prominently appear in Software Conferences. At the time I felt this was appropriate given the horror stories that had been circulating about sexual harassment and misbehavior at some of those conferences. I wrote a blog about it at the time. Since then I have seen the other side of the coin. Codes of conduct have been used as weapons to exclude people on the basis of their political opinions, or on the basis of their associations, or just because someone didn't like them. I have written blogs about this as well. (1), (2) As much as I think that codes of conduct are a good idea, we must not allow them to be weaponized. If we are going to set up rules with consequences, then we also need to set up the the due processes by which those rules and consequences are adjudicated. Otherwise the people who police the codes of conduct will be free of the due checks and balances that protect conference attendees and speakers from unfair and malicious actions. As we have seen, such malicious and unfair actions have become all too common. It seems to me that if a conference is going to publish a code of conduct, like the one below, they must also publish the process by which alleged violations will be adjudicated. That process must include provisions for the accused to be able to defend themselves against the allegation, and must also allow the accused to know the identity of the accuser(s). Otherwise all conference attendees and speakers will be exposed to malicious and falsified complaints with no recourse to defend themselves. The conference I was disinvited from is over. I was ejected because code of conduct complaints were registered against me by three relatively minor speakers in quick succession. I do not know if those speakers acted in concert. Nor am I certain of the identities of those speakers (though I have a good idea). What I do know is that three or four weeks befor

## The Disinvitation

DevFeed: [The Disinvitation](<https://devfeed.tech/articles/the-disinvitation-21788.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2020/09/12/TheDisinvitation.html>)

Published: 2020-09-12T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [Website](<https://devfeed.tech/topics/website.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [code-of-conduct](<https://devfeed.tech/tags/code-of-conduct.md>), [community](<https://devfeed.tech/tags/community.md>), [conference](<https://devfeed.tech/tags/conference.md>), [covid](<https://devfeed.tech/tags/covid.md>), [presentation](<https://devfeed.tech/tags/presentation.md>), [speaking](<https://devfeed.tech/tags/speaking.md>)

### AI overview

The author describes being disinvited from a Chicago software conference shortly before it became virtual. Organizers cited concerns from Code of Conduct representatives about the author's political opinions, while some speakers reportedly refused to participate if the author spoke. The author argues that the organizers may have breached an agreement and that the other speakers may have committed tortious interference.

### Source excerpt

I have a friend, in the Chicago area, who calls me up two or three times a year to ask me to give a talk at a User Group, or a conference he's involved with, or something like that. If my schedule is free I always say yes. I don't charge anything because I enjoy supporting the Chicago software community, and it's never a bad thing to get my face out in front of new people. I am a consultant, after all, and giving pro-bono talks is one of the ways I promote myself. Anyway, he wrote to me last October (That's right, a full year ago!) and asked me to give a presentation at a Chicago conference this September 21st. I agreed, and he thanked me, and that was that. Then, in June, he wrote to tell me that the conference was going to be virtual due to Covid. I acknowledged and, once again, that was that. Last Wednesday, September 9th, twelve days before the conference, he called me on the phone and said: "This is going to be the most uncomfortable phone call I have ever made." He went on to say that the "Code of Conduct" people at the conference were concerened about some of my political opinions, and that some of the speakers of the conference refused to speak if I was going to speak. Like I said, this guy is a friend of mine, and I don't want to get him into any trouble, so I decided not to raise a fuss about it, and I promised him I would not mention his name or the name of the conference on line. He responded by telling me: I'm scared to death of these people. Over the last few days I've been mulling this situation over in my mind, and I've come to a few interesting conclusions. The conference organizers are in breach of contract. OK, we didn't have a formal written contract, but we had emails. And we also had the fact that, for the better part of a year, the conference website had my picture on it, and advertised me as a speaker. I conclude that the conference organizers derived substantial benefit from those pictures and from promising my virtual presence to their audi

## REPL Driven Design

DevFeed: [REPL Driven Design](<https://devfeed.tech/articles/repl-driven-design-21787.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2020/05/27/ReplDrivenDesign.html>)

Published: 2020-05-27T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Code](<https://devfeed.tech/topics/code.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [coronavirus](<https://devfeed.tech/tags/coronavirus.md>), [data](<https://devfeed.tech/tags/data.md>), [github](<https://devfeed.tech/tags/github.md>), [mocking](<https://devfeed.tech/tags/mocking.md>), [tdd](<https://devfeed.tech/tags/tdd.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

The article reflects on using REPL Driven Design while developing a Clojure program that processes daily Coronavirus statistics from the Johns Hopkins GitHub repository. The author found REPL experiments and tests fast and confidence-building, and real production data reduced the need for mocks and fake data. However, a later design change exposed weak verification, delayed the change, and ultimately allowed a bug into production that was discovered four days later.

### Source excerpt

If you follow me on facebook you know that I've been publishing daily CoronaVirus statistics. I generate these statistics using the daily updates in the Johns Hopkins github repository. At first I just hand copied the data into a spreadsheet. But that became tedious quite rapidly. Then, in late March, I wrote a little Clojure program to extract and process the data. Every morning I pull the repo, and then run my little program. It reads the files, does the math, and prints the results. Of course I used TDD to write this little program. But over the last several weeks I've made quite a few small modifications to the program; and it has grown substantially. In making these adaptations I chose to use a different discipline: REPL Driven Design. REPL Driven Design is quite popular in Clojure circles. It's also quite seductive. The idea is that you try some experiments in the REPL to make sure you've got the right ideas. Then you write a function in your code using those idea. Finally, you test that function by invoking it at the REPL. It turns out that this is a very satisfying way to work. The cycle time - the time between a code experiment and the test at the REPL - is nearly as small as TDD. This breeds lots of confidence in the solution. It also seems to save the time needed to mock, and create fake data because, at least in my case, I could use real production data in my REPL tests. So, overall, it felt like I was moving faster than I would have with TDD. But then, in late April, I wanted to do something a little more complicated than usual. It required a design change to my basic structure. And suddenly I found myself full of fear. I had no way to ensure that those design changes wouldn't leave the system broken in some way. If I made those changes, I'd have to examine every output to make sure that none of them had broken. So I postponed the change until I could muster the courage, and set aside the dedicated time it would require. The change was not too painful.

## A Little More Clojure

DevFeed: [A Little More Clojure](<https://devfeed.tech/articles/a-little-more-clojure-21786.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2020/04/09/ALittleMoreClojure.html>)

Published: 2020-04-09T00:00:00Z

Content type: tutorial

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Code](<https://devfeed.tech/topics/code.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [java](<https://devfeed.tech/tags/java.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [tdd](<https://devfeed.tech/tags/tdd.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

An introduction to additional Clojure utility functions, including map, filter, range, let, and anonymous functions. The article applies these concepts to finding prime numbers up to one thousand and demonstrates a variant of test-driven development, immutable local bindings, and interoperability with Java libraries.

### Source excerpt

So let's learn just a little bit more of Clojure. Here are a few common utility functions: user=> (inc 1) ; increments argument 2 user=> (dec 3) ; decrements argument 2 user=> (empty? []) ; tests for empty true user=> (empty? [1 2]) false If you know Java or C# you probably know what the map function does. Here's an example: (map inc [1 2 3]) evaluates to (2 3 4). The first argument of map is a function. The second is a list. The map function returns a new list by applying the function to every element of the input list. The filter function also takes a function and a list. (filter odd? [1 2 3 4 5]) evaluates to (1 3 5). From that I think you can tell what both the filter and the odd? functions do. And so with that, let's try a little challenge. Let's find all the prime numbers between one and a thousand. We'll use a variant of TDD to do this. Our eyes will be the tests. The cycle will be the same size as normal TDD; but we'll write a bit of code first and then test it. I know. Blashphemy! So sue me. ;-) We begin like this: (defn primes [n] ) This returns nil. user=> (primes 1000) nil Now let's get all the numbers between 1 and n. (defn primes [n] (range 1 (inc n))) user=> (primes 10) (1 2 3 4 5 6 7 8 9 10) You've probably figured out what range does. It just returns a list of all the integers between it's arguments. OK, so now all we have to do is filter all the primes: (defn primes [n] (let [candidates (range 1 (inc n))] (filter prime? candidates))) CompilerException java.lang.RuntimeException: Unable to resolve symbol: prime? in this context, compiling:(null:3:5) Oh, oh. We need to implement prime? (defn prime? [n]) user=> (primes 10) () OK, that makes sense. But I should explain the let function. It allows you to create names that are bound to expressions. The names exist only within the parentheses of the let expression. So it's a way to create local variables - though the word "variable" is not quite right because they cannot be reassigned. They are immutable.

## A Little Clojure

DevFeed: [A Little Clojure](<https://devfeed.tech/articles/a-little-clojure-21785.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2020/04/06/ALittleClojure.html>)

Published: 2020-04-06T00:00:00Z

Content type: article

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Clojure](<https://devfeed.tech/topics/clojure.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

An introduction to Clojure covering list syntax, arithmetic and built-in functions, the REPL, quoting, and the implementation of lists as linked lists.

### Source excerpt

So let's learn just a little bit of clojure. This expression: (1 2) represents the list containing the integers 1 and 2 in that order. If you want an empty list, that's just (). And the list of the first five letters of the alphabet is just (\a \b \c \d \e). Now you know a lot about the syntax of clojure. Perhaps you think there's a lot missing. Well, there are a few things missing; but far fewer than you'd think. You might be wondering how you add two numbers. That's easy, that's just (+ 1 2). As it happens that's also just the list of the function named + followed by a 1 and a 2. You see, a function call is really just a list. The function is the first element of the list, and the arguments are just the other elements of that list. When you want to call a function, you simply invoke the list that represents that function call. There are quite a few built-in functions in clojure. For example there's +, -, *, and /. They do precisely what you'd think. Well, perhaps not precisely. (+ 1 2 3) evaluations to 6. (- 3 2 1) evaluates to zero. (* 2 3 4) evaluates to 24. And (/ 20 2 5) evaluates to 2. (- 5) evaluates to -5. (* 5) evaluates to 5. And, get ready for this, (/ 3) evaluates to 1/3. That last is the clojure syntax for the rational number one-third. (first 1 2 3) evaluates to 1, (second 1 2 3) evaluates to 2, and (last 1 2 3) evaluates to - you guessed it - 3. If you'd like to see this in action you'll need to start up a clojure REPL. You can google how to do that. The word REPL stands for Read, Evaluate, Print Loop. It's a very simple program that reads in an expression, evaluates that expression, prints the result of that expression, and then loops back to the read. If you start a REPL you'll get some kind of a prompt, perhaps like this user=>. Then you can type an expression and see it evaluated. Here are a few from my REPL user=> (+ 1 2 3 4) 10 user=> (- 5 6 7 8) -16 user=> (* 6 7 8) 336 user=> (/ 5 6 9) 5/54 If you try the expression at the very start of this

## Open Letter to the Linux Foundation

DevFeed: [Open Letter to the Linux Foundation](<https://devfeed.tech/articles/open-letter-to-the-linux-foundation-21783.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2019/11/08/OpenLetterLinuxFoundation.html>)

Published: 2019-11-08T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Linux](<https://devfeed.tech/topics/linux.md>), [Development](<https://devfeed.tech/topics/development.md>), [.NET Conf](<https://devfeed.tech/topics/net-conf.md>)

Tags: [community](<https://devfeed.tech/tags/community.md>), [development](<https://devfeed.tech/tags/development.md>), [event](<https://devfeed.tech/tags/event.md>), [executive](<https://devfeed.tech/tags/executive.md>), [kubecon](<https://devfeed.tech/tags/kubecon.md>), [legal](<https://devfeed.tech/tags/legal.md>), [linux](<https://devfeed.tech/tags/linux.md>), [open](<https://devfeed.tech/tags/open.md>), [organization](<https://devfeed.tech/tags/organization.md>)

### AI overview

An open letter to the Linux Foundation criticizes its public handling of a Code of Conduct complaint involving Charles Max Wood and the revocation of his event registration. The author argues that complaints, proceedings, and individual decisions should remain private and confidential to prevent harassment and harm.

### Source excerpt

To: The Linux Foundation Jim Zemlin: Executive Director Angela Brown: VP of Events Andy Updegrove: Legal Council From: Robert Martin (@unclebobmartin) (unclebob@cleancoder.com) Re: Code of Conduct case of Charles Max Wood. Dear Linux Foundation: I am writing to you as a concerned member of the software development community which I have enjoyed serving for the last 50 years. I am writing in public because the events I wish to describe took place in public. I fear that something has gone terribly wrong within your organization; and that it will have deep repercussions within this industry that I cherish. The timeline of events, as far as I can determine them, is as follows: The Linux Foundation received a public tweet sent to the @KubeCon twitter address. That tweet recommended that Kube Con discontinue their association with Charles Max Wood. The reasons given in this complaint were his request for an open and civil phone call, and a picture of Mr. Wood wearing a MAGA hat. The Linux Foundation publicly replied from the @linuxfoundation twitter account as follows: Hi all, We have reviewed social and videos and determined that the Event Code of Conduct was violated and his registration to the event has been revoked. Our events should and will be a safe space. First let me say that I find it highly problematic that the complaint and the decision were public. Indeed I am surprised that LF would accept a publicly submitted code of conduct complaint. I am much more than surprised that LF would ever consider publicly responding to such a complaint. Indeed, it seems to me that the public complaint, and perhaps even the public response by LF, could be seen as public harassment - which is explicitly prohibited by the LF Code of Conduct. It seems to me that Code of Conduct complaints made in public must be immediately rejected and viewed as Code of Conduct violations in and of themselves. Code of Conduct complaints should be submitted in private and remain private and confiden

## What They Thought of Programmers.

DevFeed: [What They Thought of Programmers.](<https://devfeed.tech/articles/what-they-thought-of-programmers-21782.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2019/11/03/WhatTheyThoughtOfUs.html>)

Published: 2019-11-03T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [culture](<https://devfeed.tech/tags/culture.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

The article examines how programmers and programming have been represented in popular culture over roughly six decades. It begins with early science fiction, especially Forbidden Planet, where programming is implied through intelligent machines and Dr. Morbius is portrayed as their creator.

### Source excerpt

It is interesting and educational to go back in time and look at how programmers were represented in popular culture. What did they think of us? Did they know who were? It's important to remember that prior to 1946 there were no programmers, that computers themselves were virtually unknown until the late '50s. That virtually nobody lived next door to a programmer back then. Nowadays virtually everyone in the western world, and even in much of the developing world, is surrounded by computers. And while programming remains a mystery to many, programmers are common neighbors. So let's scan the last six decades and watch as the culture changes it's view of just who we are and what we do. 1956 Forbidden Planet It's best to begin at the beginning. The first truly classic Science Fiction movie. Forbidden Planet. If you haven't seen it, you are missing something profound and spectacular. I urge you to watch - even study - it. There are no explicit mentions of computers or programmers in this movie. The concept was simply not something that the public could relate to. However there was a machine. A very big machine. And the implication was that it was intelligent, but not sentient. In the movie the anti-hero Dr Morbius is marooned on the uninhabited world of Altair 4. He discovers an ancient alien machine. Two decades later rescuers arrive. He shows them the machine and states: "I have reason to believe that years ago a minor alteration was performed throughout the entire 8000 cubic miles of it's own fabric." The programmers of that big machine are long dead; but they are described as belonging to a highly evolved and benevolent alien race. There is another machine on this planet. It is a robot named Robby. Robby is clearly intelligent and sentient. Robby speaks English, with the inflection of a proper british butler, rather in the manner of Carson on Downton Abbey. Dr. Morbius claims to have created the Robot; so he is clearly the programmer. Morbius is studious, austere, e

## Circulatory

DevFeed: [Circulatory](<https://devfeed.tech/articles/circulatory-21781.md>)

Original publisher: [Read original article](<http://blog.cleancoder.com/uncle-bob/2019/10/31/Circulatory.html>)

Published: 2019-10-31T00:00:00Z

Content type: opinion

Language: en

Sources: [Robert C. Martin](<https://devfeed.tech/sources/robert-c-martin.md>), [The Clean Code Blog](<https://devfeed.tech/sources/the-clean-code-blog.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Internet](<https://devfeed.tech/topics/internet.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [information](<https://devfeed.tech/tags/information.md>), [internet](<https://devfeed.tech/tags/internet.md>), [iphone](<https://devfeed.tech/tags/iphone.md>), [mac](<https://devfeed.tech/tags/mac.md>), [photos](<https://devfeed.tech/tags/photos.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

The article presents software as the circulatory system of civilization, using a family story to show how Photomyne, the Photos app on Mac, 23andMe, email, FaceTime, and the internet helped relatives discover one another and share a treasured old photograph.

### Source excerpt

My wife and I both got genetic analyses from 23andMe recently. I discovered that my ancestry comes from Britain and Northern Europe. My wife is Mexican, and she found that her ancestry is very diverse. One of the services of 23andMe is that they offer to connect you to relatives who have also used 23andMe. Using this service my wife found a second cousin whom she had never met, but whose extended family had overlapped with hers. By email they were able to compare the names of aunts and uncles, and the towns where they lived. The more they talked, the more they realized that the overlap with the extended families was large. Some years back I went through the effort of scanning all the old photo albums that we had created or inherited over the years. From that trove of digitized pictures my wive was able to find a 50 year old photograph of that extended family, taken in a little town in Mexico. She shared that photo with her relative who happened to be visiting that town at the moment. The relative showed the picture to her aunts, uncles, cousins, and they all started pointing to people that they recognized. Many tears flowed as warm recollections were conveyed. This is apparently the only surviving photograph of that extended family; and now they all have, and cherish, it. Now I want you to consider what made this possible. I scanned those pictures on a whim, using Photomyne an iPhone app that makes scanning and cataloging old photos very easy. My wife was able to find that picture using the Photos app on the Mac. The software at 23andMe was able to find her distant relative. Email and FaceTime allowed the two to communicate. And the internet ran through it all. Software. It was software that drove the connection of all those people. It was software that enabled the warm tears of recollection to flow. It was software that provided the photo to the folks in that little town in Mexico, who had not seen the faces of their loved ones in 50 years. It was Software. It was