I have an ambiguous attitude towards technical podcasts. On the one hand, if you are well acquainted with the topic, then you are unlikely to learn a lot of new things, and if the topic is new for you, then it is quite difficult to get to know it in an hour of audio material. In addition, not every topic in the field of software development can be described without code examples, diagrams and drawings. But nevertheless, from time to time there are quite interesting podcasts, which tell about new products in a particular area, or conduct interviews with interesting and often well-known comrades who even manage to tell a lot of interesting things even in such rigid frameworks.
So I recently came across a “progmatic” podcast with Robert Martin
, a “companion” quite well-known, the author of the SOLID
principles (more precisely, this abbreviation), several books, and in general a person with more than forty years of experience in our area. Since quite a bit of this fame falls on the SOLID abbreviation, it is not surprising that in every interview with Bob’s “uncle” he is asked this question. But in this case, my interest was caused not by the fact that Robert still remembers these principles, but by the fact that these principles have been around for almost 20 years. According to Robert, this term appeared somewhere in 1993 as a result of communication in USENET. It turns out that the concept itself took almost a decade to become famous.
Another no less interesting topic was the idea that it is very difficult (if at all possible) to develop reusable code from the very beginning. Of course, no one tries to convince anyone that reuse is impossible or the development of any library is doomed, rather, it’s about the fact that program development is a difficult task, and the development of reusable programs is even more so. And when architectural or design decisions are made in the early stages of development, based on the assumptions of some kind of community, this often leads to a waste of resources. Trying to create a generalized solution when it is not really clear what one single program will do is not such a good idea.
Bob thinks (and I agree with him) that such reusable parts of systems can be “grown” (or developed) rather than developed from scratch on purpose. In this case, when developing a system, it is sufficient to use well-known generally accepted design principles. It’s not for nothing that Eric Lippert (and many other specialists) considers one of the main problems of the software to be a premature generalization, when unjustifiably complex design or architectural solutions are taken to please potential benefits, as a result of which we don’t get reuse. we cannot even bring one system to mind. The result is an overcomplicated system that begins to crumble under its own weight, and then other concerns begin: how to make ends meet and at least somehow bring the current project to mind.
Also, Bob Martin reveals the secret of searching for qualified personnel: in order to find highly qualified specialists, it is enough to attract ... highly qualified specialists to their search. Such a question resembles the well-known philosophical question of what comes first, the chicken or the egg. But nevertheless, as practice shows, it is much easier for highly qualified specialists to find like-minded people in the person of specialists of the same level. But what to say, the process of selecting people is still difficult, and the assessment of the level of the candidate is extremely subjective, but nevertheless, you have little chance of getting a professional at your disposal if the newcomer interviews him. After all, how to determine in this case, the person really knows something or his language is simply suspended and he is famously able to bait bikes.
This is not the whole list of questions that Robert Martin and Majells Forest talked about (this is the name of the host). The podcast also discussed the role of business analysts, training and mentoring, functional programming and dynamical languages, SICP
and more. So I didn’t reveal all the cards and it should still be very interesting to listen to.
Here are some more podcasts that I occasionally listen to (the list is not complete, but it may interest someone):
1. Pragmatic Podcasts. There are not many podcasts here at all, and most of them are devoted to books that have come out of the hands (or from which there are books) published by Pragmatic Bookshelf. So there are different topics and you need to choose exactly what interests you. But some of them, I think will interest a fairly wide audience.
1.1. Robert Martin interview
1.2. Andy Hunt on Pragmatic Wetware
1.3. Dave Thomas on Pragmatic Publishing
2. Software Engineering Radio. This is one of the most serious and popular podcasts and it should rightfully go first on this list. The range of topics there is very wide and, I think, everyone will find podcasts dedicated to an area of interest to him.
3. Code Cast. Although these podcasts are called “Code Cast - The Late Night Show for .NET Developers”, there you can find a lot of useful things not only for a .Net programmer, since the list of topics that go up there is quite wide: from PowerShell and Iron Python, ending with SOLID principles, UML, and iPhone development.