Learning new coding patterns – how to start?

> What resources do you recommend folks at my level look into?

I'd argue that your best bet for learning is starting a project that drives you, then throwing that project away and starting it over again but try to make the code simpler. This way you can hone into what abstraction is actually necessary to solve your problem.

I strongly recommend ignoring design patterns and instead honing in on what the essential data flow is in your problem space. Most design patterns will bloat your code base and, thus, slow both your program and your programming velocity down.

As far as programming design and architecture goes, the best talks I have found come out of data orientated design talks. Casey Muratori has a number of talks well worth listening to[0][1][2]. I also enjoy Andrew Kelley's talk on Data Orientated Design specifically as it demonstrates DOD's power with actual numbers to back it up[3].

Tangent: I did my time with OOP design + trying to make my code 'clean' according to popular recommendations you'll see online. All of that time, I consider wasted because I focused too much on what the 'right' abstraction to use was, instead of solving my problem in the simplest way possible. I find now that often the best solution is the one that uses the least amount of abstraction and indirection. (E.g. One big function can be a lot easier to maintain than multiple little functions, you just have to develop a taste for when a function should be split up and why).

(If you must have a pattern to study though, the strategy pattern is the only one worth it. Often times, a simple switch statement is all you need for implementing the stategy effectively.)

[0] https://youtu.be/ZQ5_u8Lgvyk?si=uiiEwxMO1PjIEdxD [1] https://youtu.be/5IUj1EZwpJY?si=HCzyynWW425huM65 [2] https://youtu.be/tD5NrevFtbU?si=Y1mZZJsW21WDRMtu [3] https://vimeo.com/649009599

> What resources do you recommend folks at my level look into?

You could take a look at the classics (design patterns by the gang of four)

Besides pure reading / doing theoretical reasearch I would strongly recommend to do practical exercises in different programming languages.

Since the nature of different programming languages is to solve different problems in better ways, I would aim for languages with different concepts [1].

Try to understand concepts in modern languages (python, JavaScript, Java, c, rust, go, etc.) but also more uncommon like LISP, SmallTalk or Erlang.

[1]: https://pilabor.com/blog/2021/05/learn-concepts-not-framewor...

I have to disagree with some of the other posters in this thread: I think the only way to learn to control growing complexity of a software project is to use software patterns extensively, disregarding any associated productivity costs.

Don't forget about the two broadest programming methodology alternatives: Object-Oriented Programming (OOP) and Functional Programming (FP). Each has its own set of design patterns: OOP has the "The Gang of Four" -style patterns, FP has function composition -style patterns.

It is my personal feeling that the programming world is possibly slowly moving away from OOP and gravitating towards FP (especially when it comes to UI programming), due to FP's focus on ease of code comprehension and testability.

In the OOP-centric world, Rust comes to mind as a modern programming language that encourages consistent use of assorted OOP and FP patterns. In the FP-centric world, Elm comes to mind as a practical and straightforward programming language that uses FP patterns to solve web UI development problems.

For a book on OOP, see: https://en.wikipedia.org/wiki/Design_Patterns

For OOP design patterns in Rust, see: https://rust-unofficial.github.io/patterns/

For a book on FP, see: https://www.manning.com/books/grokking-simplicity

For FP design patterns in Elm, see: https://elmprogramming.com

I was in a similar boat to yours - Worked in data science and since then have made a move to data engineering and software engineering for ML services.

I would recommend you look into the Design Patterns book by the Gang of Four. I found it particularly helpful to make extensible code that doesn't break specially with abstract classes, builders and factories. I would also recommend looking into the book The Object Oriented Thought Process to understand why traditional OOP is build the way it is.

You can also look into the source code of popular data science libraries such as sklearn (https://github.com/scikit-learn/scikit-learn/tree/main/sklea...) and see how a lot of them have Base classes to define shared functionality between object of the same nature.

As others mentioned, I would also encourage you to try and implement design patterns in your everyday work - maybe you can make a Factory to load models or preprocessors that follow the same Abstract class?

You might enjoy the book "Exercises in Programming Style (Second Edition)" by Cristina Videira Lopes. It looks at how you can compute term frequency using 40 different coding patterns, explaining the how/why of each.