Moved. See All new content goes to the new site. This is a legacy, and will likely be dropped five years after the last post in Jan 2023.

Tuesday, July 27, 2021

SOLID Coding in Python

SOLID Coding in Python by Mattia Cinelli.

Download Medium on the App Store or Play Store

This was fun to read. It has some nice examples. 

I submit that the order of presentation (S, O, L, I, D) is misleading. The acronym is fun, but awkward.

My LinkedIn Learning course covers these in (what I think is) a more useful order.

  1. Interface Segregation. I think this is the place to start: make your interfaces as small as possible.
  2. Liskov Substitution. Where necessary, leverage inheritance.
  3. Open/Closed. This is a good quality check to be sure you've followed the first two principles well.
  4. Dependency Injection. This is often about test design and future expansion. In Python, where everything really happens at run time, we often fail to parameterize a type properly. We often figure that out a test time, and need to revisit the Open/Closed principle to get things right.
  5. Single Responsibility is more of a summary of the previous principles than a distinct, new principle. I think it comes last and should be treated as a collection of good ideas, not a single idea.

I think time spent on the first three -- Interface Segregation, Liskov Substitution, and the Open/Closed principle -- pay off tremendously. The ILODS acronym, though, isn't as cool as SOLID.

The "Single Responsibility" suffers from an ambiguous context. At one level of abstraction, all classes have a single responsibility. As we dive into details, we uncover multiple responsibilities. The further we descend into implementation details the more responsibilities we uncover. I prefer to consider this a poetic summary, not the first step in reviewing a design.

Tuesday, July 20, 2021

How can people find inspiration at work? #CreateMeaning

What do I know about "inspiration" at work? I'm not sure I know much, but I think I may have some advice that could be useful.

I was in the high-tech write-software-every-day workplace since about 1976 or so. (The first two years were part-time while in college.) I use past perfect "was" because I'm old enough (and lucky enough) to be able to retire from daily work. I've switched from writing code to writing books about writing code.

For the math-impaired, my software career spanned 45 years.

Early in this career, the question of finding inspiration at work wasn't asked in the same stark way people discuss it nowadays. When I was younger, the idea of maintaining a work/life balance wasn't something we were asked or encouraged to consider. We did the best we could and tried to avoid getting replaced by someone who could do it better.

Which -- with the advantages of hind-sight -- was a terrible way to live and work. Simply awful. I was lucky enough to see hundreds of projects in my working career. I worked with scores of different organizations. There was a spectrum of bad behavior.

I did learn this: Fear is not Inspiring. I learned a few other things, but let's start with fear.

The Fear Factor

I want to dwell a bit on the fear factor in the workplace. I'm firmly convinced that some manager types suffer with a nagging background of essential fear for their own jobs. And they can project this fear onto folks around them.

Try these shoes on for a moment. The technology has moved on and you haven't kept up. You're trying to manage people, but you have a nagging suspicion your core managerial skills are weak enough that you could be replaced. Motivated by fear, you encourage "casual overtime" and "working weekends" and "meeting the committed schedule". Perhaps you feel it necessary to go so far as to demand these things.

Fear of getting fired creates an uninspiring place to work. It will be an incubator for burnout. 

Further, I suspect it can lead to worse situations than people quitting. I think the "work a little harder" folks plant seeds for various kinds of workplace abuses. 

I think there are a variety of fears. The fear of getting fired is at the bottom of Maslow's hierarchy of needs: we could get fired, and be unable to get another job. We're in the Physiological and Safety realm of the needs pyramid.

A fear of a project not working out means we'll tumble in the eyes of more senior management. This is somewhere in the higher level of Social Belonging and Esteem needs. The problem is that projects have a variety of metrics, and simply making the schedule is an easy metric and can seem to lead to immediate esteem.

What about higher level cognitive needs like Self-actualization and Transcendence? I strongly suspect fears related to these needs can color someone's workplace. I think these often show up as "Am I really going to be doing this for the Rest of My Life?" questions. This becomes an undercurrent of negativity stemming from fear of being trapped in unfulfilling work. 

We might see these fears in several places. We each harbor our own private fears. In any organization with a hierarchy, we'll have to deal with fears that trickle down to us from supervisors. In non-hierarchical organizations, we'll have to deal with fears of our peers and colleagues. We're surrounded by fears, and I think this can sap our inspiration.

What can we do to find inspiration in a work environment?

My Experience

I've worked on hundreds of projects. That means hundreds of jobs that came to an end. And when the project ended, I was no longer needed. 

In effect, I was fired hundreds of times.

This isn't a helpful thing. If Maslow's base physiological needs are met, then having a project end isn't too horrible. I was a contract programmer in the olden days when we were salaried, and the company would carry us from assignment to assignment. Being let go by a customer can be harsh, but getting paid in spite of being let go softens the blow.

I emphatically do not recommend this way of working as a source of inspiration. Some people like the constant changing gears and changing directions. Other people might find it terrifying: each project is a whole new group of people in a new organization. Potentially very unsettling.

I don't think the "get tougher" or "grow thicker skin" advice is good. I'm don't think it worked out for me. I think this kind of transience left me feeling isolated. I think it lead me to carry around a sense of superiority. So. Let's set aside any dumb-sounding advice based on a literal review of my experience. 

How Did I Cope?

Finding ways to cope, I think, is important, but it is also potentially misleading. The idea of coping with new projects, new organizations, travel, and getting fired all the time isn't inspiring. It's merely coping with an endless stream of loss and separation. 

Underpinning the idea of coping is a more foundational question. Where did I find the inspiration to keep on doing this contract programming thing for so many years? And the other question is how well my search for inspiration might apply to folks who aren't commuting computer programmers?

I think there's a first step that many people can take. It's this:

We can disentangle our self-worth from the work-place imposed sense of worth.

This may be overly glib. But. I think the things rewarded in the workplace aren't a good reflection of who we are and what we're capable of. While it's important to be confident in one's self, our confidence can be undermined by a toxic workplace. Having confidence can let us take our skills and abilities in a variety of directions. We might, for example, decide to find another workplace; one where our value is recognized. Or, we might decide to change our circumstances in the workplace we're currently inhabiting. In both cases, we're asserting our value. We're making a further claim about our value: we may not match the workplace's expectations of us. The workplace can change, or we can find another workplace.

We might see a mismatch in lousy performance reviews. These can can stem from many causes. Perhaps we're not suited for a job and need to find something else. Or, perhaps the person reviewing our work doesn't see what we could (or should) be doing. (They have their own fears, and they may not be willing to try to make the changes we'd like them to make.)

Looking back, I may have been doing this all along, without being clear or intentional about it. Perhaps I excelled at places that valued me, and failed to meet expectations at places that treated me poorly. Perhaps my job shifting was (in an indirect way) a search for a workplace that valued me, my unique experiences, and my distinctive voice.

I was not intentional about it. I stumbled from job to job, knowing the sales folks would find me a next assignment when the current assignment had run its course. I think a vague sense of self-worth is what lead me to locating inspiration in spite of a lot of change and disruption.

Finding Inspiration

When we think of inspiration, we think of a spiritual drive to do the work. This doesn't often parallel with working for pay to cover rent and expenses. 

A good manager, however, can create a cohesive team from a group of people. A group of peers can welcome a new colleague. This creates belonging and esteem: the middle levels of Maslow's hierarchy of needs. We may find that a team or a team's goal may be inspiring. This means that our own self-worth is recognized and valued by our co-workers. This can be a marvelous experience.

What about the bad manager or unhelpful group of colleagues? In this cases, we're forced to make the best of an awkward situation. I think we can do this:

We can search for inspiration at the margins of our work life. 

Can we find some side-bar aspect of the work that leads to some helpful insights? Perhaps there is a chronic problem we can take notes on and -- eventually -- fix. Perhaps someone is less helpful that others, and we can try to understand what would make them less toxic. Perhaps cleaning the break-room fridge is better than complaining about month-old food. (Yuck. But. If things are better, it may be worth it.)

For years, I had an aspiration to write about software development. To further this dream, I started taking more and more careful notes of projects I was on. In the era before the World Wide Web, publication was difficult, but not impossible. I wrote small articles for technical magazines; this effort was something that inspired me to work with customers who were inept and had horrible, horrible problems. I liked the awful customers because it provided me good examples of things that should not be done.

At the end of a horrible project, I'd have a good anecdote for what not to do.

I acknowledge my two ideas of self worth and inspiration isn't a dramatic, life-changing epiphany. I'm pretty sure the scales won't fall from anyone's eyes as they think about looking at sidebar topics as a source of inspiration.

Looking at the margins, edges, and corners of a job can help to reveal the whole job. The whole team. The whole goal. Finding this broader view might inspire us to look for a better team with better goals. In other cases, it might help us find the missing skills in the team we're on. In other cases, a better perspective might help us steer our supervisor toward doing something that's better than what they're doing right now.

There are very fine lines between toxic, poorly organized, poorly managed, confusing work places, and workplaces that are still trying to find a workable organization. Most places have a combination of good and bad, inept and well-done, confusing and sensible features. Indeed, these may all be different axes and an organization is really a multi-dimensional object with different kinds of overlaps and gaps. 

I believe the foundation for inspiration is a clear sense of self-worth. I think we create meaning in our workplace by knowing what we can contribute, what we want to contribute, and what the organization needs. Our unique contribution and what the organization needs may not overlap at all, or the organization may have always been searching for someone like us. Either way, our awareness of our skills, our experience, and our authentic voice is what lets us find inspiration.

Tuesday, July 13, 2021

What Books Should I Read? In What Order?

A fascinating question.

... I'm baffled by the amount of books you've published over the course of time. Currently Reddit suggests that I use Building Skills in Python under Beginner's section, but it looks quite outdated. So back and forth, I found your Building Skills in OO on GitHub Page and was quite happy with the read on the first 100 pages.

I searched for more info on the books you've published and wanted to know if you could sort them in ascending order of difficulty for me as I intend to purchase them slowly.

My main concern to learn Python is just to cross technical interviews and building applications that help with my workflow (they are in bash with around 200 functions, so I'm hoping to migrate them to something which is more robust). 

Currently the focus I intend to develop is on:
1) Strong Foundations of the Python Language.
2) Strong Foundations on the Basic Libraries for Data Structures and Algorithms (For example, bisect gives me insort(), calendar gives me isleap(), iter_tools gives me permutation(), etc).
3) Strong Foundations on the Design Patterns.

So could you please help me out and suggest your books?

This is challenging for a few reasons.

First, the "Building Skills" books have been reduced to only the Building Skills in OO Design. This can be found in GitHub.

That book is not really targeted to beginners, though. It presumes some core OO skills, and provides a (very) long series of exercises to build on those skills.

Second, I never really conceived of a beginner-to-expert sequence of books. From your letter, I see that I need to look at filling in some gaps in my sequence of books. I'll alert my editors at Packt, and we can consider this in the future.

Specific Needs

Let's look at your needs.

1. Foundations in the Python language.

This might be something you can learn from my Python Essentials. This isn't focused on complete n00bs. All of my books expect some programming background. Since you're an Android engineer and write code in C++ and Java, this may be helpful. This title is getting old, however, and needs a second edition.

For someone with core programming skills, I suspect that Mastering OO Python will be suitable. My Python 3 OO Programming (4th ed.) is similarly aimed at folks who can program and can learn a new language quickly.

A book like Martelli's Python in a Nutshell may provide a better foundation the way the language works than any of mine. Also Lutz's Learning Python is extremely popular.

2. Foundations in the Standard Library.

This is tricky. I touch on some of these topics in Functional Python Programming (2nd ed.) I also touch on some of these topics in the Modern Python Cookbook (2nd ed.)

I don't, however, cover very much of the library. I touch on a few really important modules. The library is vast. A book like Hellmann's The Python Standard Library by Example might be more suitable than one of mine.

3. Design Patterns.

This is central to Python 3 OO Programming (4th ed.) Dusty Phillips and I cover a number of popular design patterns in detail. 

There are -- of course -- a lot of very, very good books on Python. I'm honored you reached out to me.

Other Random Advice

Because Python is a relatively simple language (with a vast library) I have always suspected that language foundations don't really require a ton of explanation. Many languages (i.e., C++) are filled with odd details and weird features that are really unpleasantly complex. Many Java programmers get used to the distinction between the primitive int type and the Integer class type. While the Java and C++ approach can seem simple (after a while) it really isn't simple at all.

The standard library is vast, and it takes time to get used to how much is there. I would suggest having a browser tab open to at all times.

Design patterns, similarly, require some care. There are complex details around implementing the Singleton pattern in C++ and Java. Python class definitions and Python module definitions are Singletons, and using a class definition as a Singleton object is often far simpler than the commonly-used techniques for C++ and Java.

Tuesday, July 6, 2021

A Python Roadmap

An interesting tweet. The  roadmap has three sections. I'm not sure this is actually complete, or even grouped correctly. It is a very good list of topics.


I want start by quibbling about variables being first. I'm not sold on this.

I think that operators, expressions, and the built-in immutable types are foundational. int, float, str, and tuple are hugely important as core concepts in computing and Python.

I also think that "loops" is a sketchy notion and I kind of wish we wouldn't describe for and while statements as "loops". I think we should call them iterations. They implement two kinds of logical quantifiers "for all" and "there exists." I think we should talk about the final result of a for statement: all of the values in a range are processed. Similarly a for-if-break construct establishes a "for exists" that defines the first value in a range for which a condition is met. And yes, range objects will be central.

I think that a huge amount of programming can be covered with these topics. I'm not sure "basic" is the right term; foundations might be a better idea. 

The use of variables to manage state is part of this. But. Variables, assignment, and state change are a bit more advanced and maybe shouldn't be first.

I also think function definitions are foundational. Mathematics has been defining functions based on other functions. It's a way of providing a mental short-hand for complex concepts. I don't need to know all the details of how to compute a square root to make use of square root as a concept.

The wide varieties of assignment statements, including assignment to decompose collections aren't mentioned in the original post. This may be an important omission, causing me to quibble on "complete."

I agree that files and elements of File IO are part of this foundation. If we limit ourselves to reading and writing files, then they're essentially immutable structures. I think we can safely avoid update-in-place files because this is an application topic more than a language topic. Python offers the minimal level of support via seek and tell, but little more. And most modern application relies on a database for updatable files.

Data Structures

Moving from basic to intermediate. I prefer the term "data structures" which are built on the language foundations. I think that the mutable built-in data structures come next in the roadmap. My preference is to omit terms like Object-Oriented or Functional, and focus on list, dict, and set, and how the iteration works. This means comprehensions and generators are part of this essential data structure section.

No, comprehensions aren't and shouldn't be called "advanced." They're very much a core concept. Thinking about statements to implement a map/filter/reduce over a collection is the essence of a great deal of programming. We don't always learn it that way, but it needs to be presented in that framework even to beginners. A pile of for and if statements and a bunch of variables is a programmer's first step toward a simpler comprehension. In both cases, they're doing a mapping and it needs to be described as mapping one collection to another collection.

This is where the standard library collections module is introduced.  Yes it's part of the library. I think it's too central to be ignored. I think dataclasses belong here, too.

Talking about the mutable data structures means revisiting the for statement and using it on a variety of iterables. The way Python's concepts apply to a variety of data types is an important feature of the language. (In the olden days, they used to talk about "orthogonality" of data and processing; we don't need to dwell on it, but I think it helps to acknowledge it.)

Functional Programming

It appears to me that the functional programming topics can come next. The idea of functional composition via higher-order functions and decorators builds on the existing foundation. This is where map() and filter() belong. Because of the way sorted(), max(), and min() work on collections with a key= function, these are part of the functional programming roadmap. The inconsistency between map() and functions like max() is an important thing to note.

I also think itertools belongs here. We can make the case that it's in the standard library, but then, so is io. I think itertools and functools are as central to practical Python as the math module and collections.

I think typing.NamedTuple and dataclasses belong here, also. A frozen dataclass is stateless, and can be helpful when creating list comprehensions to perform a mapping from one collection to another collection.

Object-Oriented Programming

I think OO programming and related concepts build on the previous material. Class definitions and state management aren't simple, even though they're essential parts of Python.

To an extent, OO programming can be decomposed into two layers. While I hate to overuse "foundation", there seem to be two parts:

OO Foundations -- inheritance, composition, and different kinds of delegation. This tends to expose a number of common design patterns like Strategy, Decorator, and Facade.

OO Features -- this includes metaprogramming, decorators, ABC's, mixins, and the like. These topics are all designed to avoid copy-and-paste in sophisticated edge cases that cross class boundaries.


I'm not sure why concurrency and parallelism are separate topics in the original list. I've had folks try to split this hair a number of ways. The idea is to find a place where async lives that's "concurrency lite" or something.

The concepts here become blurry because threads and processes are OS features, not language features. The async/await language features, however, are clearly part of Python. It becomes particularly awful when working on something practical where asyncio doesn't provide the feature you need. Specifically, blocking file system I/O isn't part of asyncio and requires an explicit appeal to the underlying thread pool for the blocking operation. 

To an extent, async/await needs to be on the roadmap. It's tricky, though, to cover this without also digressing into threads as a way to deal with blocking operations.

Test, Integration, and Deployment

This is where tools show up. This is where pip, unittest, pytest, tox/nox, coverage, etc. live. Are these part of the language? Or are the part of the broader ecosystem?

I submit they're explicitly not part of the language. The roadmap ends just before this topic. The idea is that we should have a Python roadmap that uses the language and the standard library.

Once we've talked about the language (and some of the library) we can move on to pip and packaging. I don't think pip is and "intermediate" topic. I find that premature introduction of pip is a sign of trying to create useful interesting examples. Examples that don't use pip wind up being kind of boring. Everyone wants to play with pygame and pillow and other kinds of projects, but, those aren't foundational to the language. They're interesting and appealing and -- frankly -- a lot of fun.


I'm not a fan of the roadmap. I like some of it. I don't like some of it.

I am a fan of presenting the idea for discussion.