Seeing as your title managed to land under the same publishing umbrella as (one of my own favorite programming books as well) The Pragmatic Programmer, do you have insight as to whether your title will also be made available on the O'Reilly platform?

"The Pragmatic Programmer" is much more detailed.

Working with other great developers.

Learning to keep it simple & methods for avoiding code duplication. I tend to find when learning a new language that avoiding duplication teaches me how to use the language properly.

And the book, The Pragmatic Programmer helped me to communicate better.

"The Pragmatic Programmer" may be useful to you. It's dated but still relevant, and it was recently revised.

If it isn't clear it's not easy to change, making it "bad code."

Do what needs to be done to make the intent of a block of code super clear, in plain English. Comments don't count, as illustrated clearly in The Pragmatic Programmer, for instance.

I am interested in reading books about software development and best practices like Clean Code and The Pragmatic Programmer [0]. I have coded for about eight years, but I would like to do it better. I would like to know your opinion about [0], since Clean Code has been significantly criticized.

[0] https://pragprog.com/titles/tpp20/the-pragmatic-programmer-2...

> I helped port the full back catalog of books from The Pragmatic Programmers over to Medium

People feed the beast and then wonder why it's come back for more.

Hi everyone,

Last year, I was lucky enough to sign a book deal with The Pragmatic Bookshelf to write an intermediate level book on Python. (The Pragmatic Bookshelf is the publishing company founded by the authors of one of my favorite programming books: The Pragmatic Programmer.)

Having written Python most of my professional career, I wanted a resource that I could give to engineers who might have deeper experience in some language that wasn't necessarily Python. I wanted to help teammates newer to Python quickly discover its virtues (and limitations). I think there are tremendous Python resources available online, but wanted to capture another perspective to help teammates level up their skills.

The book ("Intuitive Python: Productive Development for Projects that Last") went through a beta release this spring, and was officially released this month.

It's available (including a few free sections) here: https://pragprog.com/titles/dmpython/intuitive-python/

In case anyone is thinking of becoming an author with the The Pragmatic Bookshelf, I'd be happy to share my thoughts about the publishing experience there (spoiler: I had a positive experience).

I'm proud to have released this book, and excited to share it here.

Thanks!

-David

> prevents people from reading content after a few times without either paying or logging in is beyond me.

I don't think this is fair or accurate.

Authors are choosing to put their articles behind Medium's paywall because they want to get paid. So when you see a paywall that's the author's choice. It's not any different than a Substack newsletter other than scale. So to say Medium is preventing people from reading... it's really that Medium is home for a lot of writers who want to get paid for their work and probably wouldn't even have written the piece you are trying to read without that incentive.

Then this Skymall article isn't even behind the paywall and doesn't have any sort of block on it or login wall. Or am I seeing something different than you? I tested it while not logged in.

FWIW, there is a ton of great writing on Medium even if there is also a lot of trash. For example, I helped port the full back catalog of books from The Pragmatic Programmers over to Medium. Those are great and it's great to have easy access to all of them.

The Pragmatic Programmer, Refactoring (I'm rereading it after many years with the 2018 edition, opinion not totally formed on this one), Working Effectively With Legacy Code, A Philosophy of Software Design. It's been a long time since I've read Clean Code, I don't quite get the hate from the other thread here today so I'm rereading it now. I figure it'll take me a couple days and worst case I'll agree with the criticism and stop recommending it.

My favourite quote from The Pragmatic Programmer is this one.

"Text manipulation languages are to programming what routers are to woodworking. They are noisy , messy, and somewhat brute force. Make mistakes with them, and entire pieces can be ruined. Some people swear they have no place in the toolbox. But in the right hands, both routers and text manipulation languages can be incredibly powerful and versatile. You can quickly trim something into shape, make joints, and carve. Used properly, these tools have surprising finesse and subtlety. But they take time to master. "

Quoted from https://flylib.com/books/en/1.315.1.37/1/

For anyone seeing this, I tried to help Medium solve this coming from the other direction, which is to make it an over the top good value for HN readers to not only log in but also pay for the $5 subscription.

That's really what Medium aspires to be--a place worthy of a five dollar subscription.

Many people here probably end up on Medium repeatedly via Google search and yeah, the results are mixed. But also, it's worth noting that a lot of those results wouldn't exist at all without Medium paying and encouraging writers and editors.

What I hoped would start to take Medium over the top though was the addition of all of The Pragmatic Programmer books. That was paid for by other tech people who had already subscribed. (And I played a role in bringing them on board).

There's more coming. But overall, this is 100% Medium's direction and belief that a soft paywall is a better business and a bigger win for all parties than free & ad supported. So this paywall isn't going away, and it's really on them to do more to justify it.

There has been plenty said about the topic. Have you read Clean Code? The Wikipedia page? The Pragmatic Programmer? The depth on the subject has been expanded far more than just “single responsibility”.

Here is Bob responding to OPs link: http://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Releva...

Stating:

“SRP) The Single Responsibility Principle.

Gather together the things that change for the same reasons. Separate things that change for different reasons.”

That’s a pretty clear delineation IMO.

Thirding Code Complete (another top-level recommended it). I read that book very early on, and I credit it with my current ability to write clean code.

Another good one is The Pragmatic Programmer.

Lastly, this wiki is a gold mine of wisdom from hardened devs: http://wiki.c2.com/?StartingPoints

I really recommend you read lots and lots of those pages.

Highly recommend starting with "The Pragmatic Programmer". I found "Clean Code" to be much more narrow in its applicability (and I did not enjoy Martin's writing, but that's highly subjective).

The Pragmatic Programmer serves as inspiration for me every time I read it. I know everything in it, but somehow I always come away with at least one "I could totally be solving my current problem with this!" insight from a re-reading.

Find a problem that he is interested in fixing.

Use programming adjacent tools that he is familiar with or wants to play with. Excel, html, no code solutions. This should be a low time investment but will either get him hooked or deter him.

Read some core books like "The Pragmatic Programmer" about general skills.

Pick up a friendly book like https://www.railstutorial.org/ for web development. I'm sure there are other similar books for other types of development.

I thing the big difference is that software is gradually becoming more declarative. It's less about coding how it does things, more about coding what it is doing. This has been the flow for many decades, but it's more common now than 5 years ago.

Something like React is the norm now. It's not necessarily any simpler or faster, but it's more efficient past N hours, which is the case for many larger companies.

It's also why functional programming has regained popularity, or at least writing functions the way you would for functional (immutable, output of one is the input of another).

However, we're still using a lot of old techniques. The best book on Design Patterns was written in 1997. Pragmatic Programmer was written in 1999 (though revisited a few years ago). The best TDD book is still from 2002; a lot of modern takes on TDD gets the philosophy completely wrong. TDD was meant to reduce fear, not improve test coverage.

You don’t think the Pragmatic Programmer books are valuable?

I don't know, but some of the people I consider to be really good software developers seem to reference "The Pragmatic Programmer" (perhaps even more than I realize do since I never read the book but have heard of "rubber duck debugging" & "DRY").

Generally, good software would have to be first defined and there's no universal definition. In most projects, I require it to have the following properties:
* New developers find it easy to ramp up on
* A handle on the defect rate (usually through adoption of best-practices like unit tests, fuzzers, automated tools, CI/CD, reproducible builds, etc).
* "Fires" infrequently enough relative to team size that it's manageable to accomplish your business goals.
* No "surprises" in adding new features/fix bugs where you didn't expect them.
* Meets business requirements today & can meet them tomorrow.

However, in other cases, like prototyping, "good software" means, "explores the problem space as quickly & cheaply as possible without worrying about any of those other things". Some of those other things can be useful in accomplishing this, especially if you plan to pivot from prototyping to the above definition. If you don't use them effectively then throw away your prototype before productionizing & start from scratch.

It sounds to me like you haven't internalized a lot of the advice in the first half of "Clean Code" and/or the entirety of "The Pragmatic Programmer". Either of those books takes a few weeks to read slowly and a few months-to-years of deliberate practice to internalize and synthesize as your own. The good news is that admitting you have a problem is the first step.

Personally I find I still frequently write pretty atrocious code on the first draft, and it's only by stepping back from the problem after demonstrating to myself I understand it well enough to solve it at all that I can begin to write a more graceful solution. But deadlines and reality being what they are, I think the majority of us are embarrassed by our past code a majority of the time.

So don't be too hard on yourself, but also frankly don't worry about shoe-horning yourself into "A Career" either. They're kind of a recent invention and the whole concept might need a few more iterations. You could spend a few years as a Product Manager, an Engineering Manager, a Highschool Teacher, or a Business Analyst, leveraging your past experience to gain competency in a new niche.

I want to emphasize of self-awareness you have is commendable and not universally present: If you can realistically assess your own current skill level and then apply yourself to improving, you could be an above average software engineer before you know it. And right now it seems like so so many companies just can't get enough software engineers, so it's a pretty safe place to practice learning how to learn while also earning a decent income.

I have written a book and have a blog on this topic. Primarily focused on "soft skills" (I think they're pretty hard) because that's what I wanted to write about.

https://letterstoanewdeveloper.com/

There are some other books covering similar ground.

From my book proposal and other research, here's a set of books/sites I'd recommend:

   * https://medium.com/basecs
   * New Programmer’s Survival Manual: https://pragprog.com/book/jcdeg/new-programmer-s-survival-manual 
   * Your First Year in Code: https://leanpub.com/firstyearincode
   * Code Complete (long and some parts aren't very modern, but very in depth)
   * The Pragmatic Programmer
   * Don't Make Me Think
   * Badass: https://boingboing.net/2015/02/27/kathy-sierras-badass-how-to.html
   * The core docs of whatever language you are using (don't underestimate the power of understanding the core libraries!)

I'll be interested to see what else is suggested here.

I agree that the Pragmatic Programmer is well done in it's audio form, and I also agree that Grokking Algorithms is terrible.

I am currently listening Designing Data Intensive Applications and it's phenomenally done - the author clearly worked with the narrator to adapt the content to audio format, and the narrator seems to have experience or familiarity with the subject because he pronounces the technical jargon very naturally.

I hope to find other software related audiobooks as good as DDAI is.

Pragmatic Programmer (importance of plain text) and How to Solve it (set of logical steps to get to grips with an otherwise overwhelming problem / situation).

Applying Domain-Driven Design and Patterns was the book that made me fall in love with software engineering. Perhaps a little dated now though.

Head First Design Patterns - I never grokked any of the patterns from the GoF book, but this one 'clicked' for me, if you can get past the cutesy presentation.

Peopleware - Shows importance of focusing on people, rather than the tech, as this is often the main cause of project failure in the software realm (and perhaps others).

As a long time Medium author and publisher and occasional business partner I have all kinds of feelings.

But the main one is about the need for urgency.

One basic way to read these changes is that it just looks like Medium getting savvier about what drives and grows their subscription business. There's been no pivot there. The challenge for them still is to get their subscription business over the hump.

And the hump they have been at for awhile is that the subscription has been growing despite being generally meh quality. It's just $5 and a lot of people like supporting authors that way. But what are the ways to go from meh to great?

What I think Medium found is that they were getting better value by spending in other places. For example, I was part of bringing the back catalog of The Pragmatic Programmers books onto Medium. That was a deal that was relatively economical and had a direct hypothesis related to growing the subscription. For programmers now, at least, they have a nice headline for why a programmer would spend $5.

So to see Medium focus more on what's working to actually tip the subscription over puts me at ease because I still see the company has being in a zero to one situation. It could succeed, but it hasn't yet.

Syntopic reading can be really rewarding. For example, once you read Thinking Fast and Slow, and a few of Taleb’s books, suddenly you notice implicit and explicit references in virtually every business book published later than those.

A similar effect can be found with Grit, Fogg’s Behavior Model, Superforecasting, and most Gladwel books.

On the coding side, I’ve only noticed this with Pragmatic Programmer, Clean Code, and maybe Phoenix/Unicorn project. Could I don’t read enough of those or they’re too focused on specific technologies instead of broad ideas … or I get too much of my technical reading from blogs and twitter. Those do get repetitive and you quickly find common patterns, but no titles to refer to.

Are there any specific aspects you'd like to improve around your code?

A few classics that focus on improving "general code style" would be:

- "Clean Code" (https://www.oreilly.com/library/view/clean-code-a/9780136083...)

- "The Pragmatic Programmer" (https://pragprog.com/titles/tpp20/the-pragmatic-programmer-2...)

EDIT: Since you are talking about coding like at a top company, one book that has been sitting on my shelf for a while, but I haven't gotten around to reading yet is "Software Engineering at Google: Lessons Learned from Programming Over Time" (https://learning.oreilly.com/library/view/software-engineeri...)

Here's my rant on Code Complete and Clean Code:

I find that these two books are in many recommended lists, but I found them entirely unforgettable, entirely too long, and without any "meat."

So much of the advice given is trivial things you'll just figure out in the first few months of coding professionally.
Code for more than a week and you'll figure out how to name classes, how to use variables, how scope works, etc.
The code examples are only in C++, Java, and Visual Basic (ha!). Completely ignoring non-OO and dynamic languages.
Some of the advice is just bad (like prefixing global variables with g_) or incredibly outdated (like, "avoid goto"? Thanks 1968!).

Work on a single software project, or any problem ever, and you'll know that you need to define the problem first. It's not exactly sage advice.

These are cherry-picked examples, but overall Code Complete manages to be too large, go into too specific detail in some areas, while giving vague advice in others.

All books are written in a time and a few become timeless. Software books have an especially short half-life. I think Code Complete was a book Software Engineering needed in 2004, but has since dropped in value.

I will say, that Code Complete does have utility as a way to prop up your monitor for increased ergonomics, which is something you should never ignore.

I have similar issues with Clean Code. One is better off just googling "SOLID Principles" and then just programming using small interfaces more often and use fewer subclasses.

A better alternative is (from above) The Pragmatic Programmer (2019), a good style guide, and/or get your code reviewed by literally anyone.