Design Patterns: Elements of Reusable Object-Oriented Software

IMHO that class sucks anyway, if you really want to learn how to do OOP design just find a good book on design patterns Link and read through it. Hell, most design patterns essentially boil down to just using an interface, but there's 100 different names for it for almost no reason. Also that class spent a lot of time, at least in the first half, on UML which is an entirely dead and useless concept.

Gang of Four Design Patterns

Written for C++, but easily adapted to Java.

It's not necessarily system design per se, but the classic Design Patterns book sheds some light on common ways of structuring software which plays heavily into system design, especially the questions you'd get during interviews.

Also this blog post is a pretty good picture of how I'd personally talk about a more high-level system design question in an interview.

It seems to me you looking for design patterns more than anything else.

If you're after design patterns the I think the Bible is still the Gang of Four https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=mp_s_a_1_1?keywords=0201633612&qid=1580769621&sr=8-1

The is the most famous book on the topic:

https://www.amazon.com/dp/0201633612/

Really a classic.

Design Patterns (aka GoF) doesn't teach OOP on its own, but it teaches a number of applications of OOP principles to solve specific problems. It has examples in C++ and Smalltalk, but is largely language-agnostic. I think it's much easier to learn OOP this way than it is by learning about a Ford extending a Car and implementing Driveable, with four objects of type Wheel, or all the other real-world analogies places tend to use that don't really map to software design.

Modular or object-oriented, what ever you decide to call it, this is the correct way to write code.

• SAD sounds like it's basically about making a ton of UML diagrams and doesn't really cover what I'd expect it to (design patterns and when to use them.)

• SDP is just kind of a joke. Don't really know how else to explain it, lol. I can't imagine using one of my 10 courses to learn git, unit testing, and Android Studio.

• With regards to databases, I just think there are much more effective and efficient ways to learn the material. You're dropping $800 to spend a majority of your time creating a UI. I'm fine with focusing on relational databases, but the notation they force you to use for your diagrams is outdated and literally not used in industry (or academia, for that matter.) Find a solid MOOC on udemy for $10.

Plus, all three have group projects, which I would advise avoiding like the plague.

Design Patterns: There are alot of them, but you really only need to learn a few basics. This book is what I used to get through university.

Sorting Algorithms: Bubble sort, Merge sort, etc etc etc

A. P. I. E. : Abstraction, Polymorphism, Inheritance, Encapsulation. Learn what each of those are and how they are used in Java.

I took this last semester and I really liked it. I'm not the best programmer in the world so I struggled (I got a B-) but I definitely learned a lot. The one thing I don't like about the class is that there was only one in-person lecture per week, and the rest of the learning was done on your own. I personally like classes with three lectures a week. However, you learn a lot about C++, and Yufeng - although dry at times - does an solid job of teaching; he's really knowledgable. The final project we had to make was a console text editor from scratch, using different OOP patterns. Honestly, the project was really intimidating for me when we first started, but it ended up the being the best class assignment I've had in college just cause of how much I learned. Even though I had trouble, the TA I had was really helpful and students shared a ton of information with each other on Piazza as well. I think in difficulty, the first part of the class (just learning C++) is similar to 3100, but the second part (the OOP patterns and semester project) is definitely harder, albeit a good learning experience. Here's the book we used if you wanna get an idea of what kind of concepts were covered in the second half. Personally, I would recommend the course. Even though it's hard, it's a good learning experience with a smart professor.

the advice that you should model objects according to real world objects should not be taken too literally.

In my opinion that advice is almost completely useless except for beginner programmers that need a clear example to start grasping the concepts of oo programming.

consider this: if you start modeling the real world then where would you stop modeling? if you model a car then you'd create objects for steering wheel, seats, tires, etc etc. but then your ask yourself what does the car drive on? so you model a road. but where does it lead? a city that is in a country that is on the earth that is in the universe.... and does it stop at the universe level? who can say?

also you should know what a model actually means in terms of software development. a model is an abstraction of your problem domain that leaves out any irrelevant property so that the model becomes a useful representation of that problem domain. By it's definition it is not the same as the real world.

so where to stop abstracting? following the solid principles you stop abstracting details out of the model when you have reached the point that the object only had only one reason to change. well there you have it! :-)

if you want to understand more of oo modeling then read the book Applying UML and Patterns of Greg Larman. Especially the GRASP patterns part.

https://www.amazon.com/Applying-UML-Patterns-Introduction-Object-Oriented/dp/0131489062#:~:text=Programming-,Applying%20UML%20and%20Patterns%3A%20An%20Introduction%20to%20Object-Oriented%20Analysis,Visit%20Amazon's%20Craig%20Larman%20Page

Also learn SOLID by heart and also read clean code of robert martin

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship-ebook/dp/B001GSTOAM

also take special notice of the pure fabrication part of the uml book. the complete design patterns book of the gang of four has patterns that can be considered pure fabrication. if one thing is super important in oo programming then it is the usage of those design patterns.

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=mp_s_a_1_1?dchild=1&keywords=gof+design+patterns&qid=1608464224&sprefix=gof+desi&sr=8-1

so go ahead and read these books. afterwards come back here with any additional questions you have which i know you will have many after reading those books :-)

https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=mp_s_a_1_3?

https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599/ref=mp_s_a_1_1?keywords=refactor&qid=1584495497&sr=8-1

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=mp_s_a_1_3?

These are three books that can help you design, write, and refactor your code with best practices in mind. Maybe not for beginners but if you have decent programming fundamentals these can help you write cleaner code.

the factory pattern is not specific to drupal. it's a very common computer science design pattern.

https://www.tutorialspoint.com/design_pattern/factory_pattern.htm

there are many books on design patterns in software engineering, the most famous and well respected book on the subject is

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

The canonical source is always Design Patterns: Elements of Reusable Object-Oriented Software by Gamma, Helm, Johnson, and Vlissides (a.k.a. the "Gang of Four"). ISBN: 0-201-63361-2

The "cliffs notes" version is Head First Design Patterns by Freeman, Freeman, Sierra, and Bates. ISBN: 0-596-00712-4

For other design patterns that aren't covered in the GOF book, I recommend Patterns of Enterprise Application Architecture by Fowler. ISBN: 0-321-12742-0

What sort of guidance? There are many ways.

If you are looking for guidance to improve your designs and code, the SOLID design principles are probably the very first place to start. And after that, probably design patterns. I would recommend the book "Design Patterns" by "The Gang of Four", it's usually seen as the definitive resource for learning not only design patterns but also understanding the problem each pattern is good for solving and when and when not to use them.

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

If you are looking for guidance for any other aspect of development, you'll need to be a bit more specific...

Would you recommend this book for SAD? https://www.amazon.com/gp/product/0201633612/ref=ppx_yo_dt_b_asin_title_o01_s00?ie=UTF8&psc=1

Clean Code Book for learning how to code well and to learn a few of the SWE buzzwords like SOLID and DRY.

Design Patterns to get through those Java/OOP interviews, and to get acquainted to writing code often seen in enterprise systems.

Introduction to Algorithms if you want to take a really deep dive into algorithms.

I've been down voted to hell for this, but whatever. you gave a low effort post so what the fuck did you expect? did you not use the search? don't waste out time first, fuckbag.

Good for you! Python is a good start with lots of web based resources. Figure out how to write software and then look at where you want to go. if you want to be a software engineer, then it doesn't matter what language you use, just how you use it. figure out unit testing and object oriented principles. Learn wtf a compiled and interpreted language is and why they are different, cohesion vs coupling, pass by ref vs value, pointers and memory allocation, and how disk writing works. etc, etc. The old shit is in c/c++ or vb, the new shit is in java, javascript, ruby on rails, etc, hell some teams use go. Different teams and areas use different languages, so it doesn't really matter. Figure out where you want to go, figure out what they use, then learn that.

here is a good book https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

there are lots of others. Most he info is out there free and in the open. Software engineering is not rocket science, even i manage to do it.

don't get someone killed writing bad code, chia suck.

Depends on how far along your journey you are, but I'd recommend Clean Code by Robert Martin. Follow that up with the blue book (Domain-Driven Design), the red book (Implementing Domain-Driven Design), and the gang of four (Design Patterns).

These all require a baseline-level understanding of how software projects are structured, but they're not very computer science-heavy or require you to sit at your desk programming as you read. Think of them as guidelines and manuals for how to think about writing software programs. Some of the concepts will go over your head (again, depends on how far along your programming journey you are) but many will stick, and a few will stick out and light the bulb over your head. They're crucial to understanding the craft of putting software together. As you mature as a programmer, you'll find yourself homing in on these concepts on your own - save yourself the trouble of reinventing the wheel and work your way through these.

Plus they're pretty well-written and very accessible :)

Read these:

https://www.amazon.com/Object-Oriented-Analysis-Design-Applications-3rd/dp/020189551X

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/

https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420

This will do you much better than any tutorial out there.

You've identified the question! That's a great first step. Learning how to answer it for any given project -- because there is no one-size-fits-all architecture -- is an entire career path. Here are some books I've found useful for informing how I think about software design and architecture. While not all of them are about architecture specifically, all of them are about software design in general.

• Refactoring
• Enterprise Integration Patterns
• Design Patterns

> Is there anything better than just reading and analysing more code?

Instead of reverse engineering the purpose behind the code, you could learn the patterns that you'll then recognize in some of the code. "Design Patterns"[1] has been popular for a long time. https://phptherightway.com/pages/Design-Patterns.html and https://github.com/domnikl/DesignPatternsPHP might also be useful.

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

1. What a technical interview is and how to be successful in one

There's simply nothing in the curriculum that's going to teach you how to go through the actual process of getting a job at a tech company. The book Cracking the Coding Interview, along with the videos that Google has up on one their Youtube channels, is a great way to start getting a handle on what this process looks like, what's expected, and how you can be successful.

2. Version control, e.g. git

No professors (at least when I was there) teach version control, or require it to be used in their classes in the CS program at Auburn, and apparently the is an issue at lots of schools. I read some tutorials on git, then starting using it just to get my projects up onto GitHub to showcase. Then, I started using it for class projects - and eventually research work - that I was working on. By the time I graduated I was proficient with it; not a wizard, but proficient enough to be able to do my job on day one. It's really not complex once you get your head around it, which makes it even more head-scratching that it's not introduced at all in the curriculum since literally every engineering org worth their salt uses some kind of version control and always will.

3. Bit manipulation

I know the basic concepts from classes like Digital Logic Circuits, and I know the implementation basics from having done some research work in C, but that's it. I've never had it come up in interviews, much less my job, but I know that this is something that could come up in an interview problem some time and I don't really know anything about those types of problems or their common solution approaches.

4. Dynamic Programming

I have had this come up in an interview, and if you do a loop at, say, Facebook, Amazon, and Google, you'll probably get at least one as well.

5. Design Patterns (kinda)

A few of these were brought up in COMP 2210 ("java 2"), but they were really just glossed over. They're something that I use and refer to for almost every implementation task I do, and definitely every design I write. The farther you are into your career the more you'll need to know and use these, so it's probably fine that you just get told that they exist and what their purpose is in school, but it doesn't hurt to know about them for interviews and you'll likely be expected to know a few common ones early on in your career (for example, my team has a design pattern book that belongs to the team that gets passed around to new team members). I recommend the ]Gang of Four book, "Design Patterns: Elements of Reusable Object-Oriented Software."](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)

6. Scalability and system design

This isn't something that comes up in entry-level interviews, since apparently it's normal to learn about these things on the job. That's all well and good, but having a knowledge of these concepts would have done a long way to helping me be more comfortable working on a web service straight out of school.

Take your son to a local university. A 13 year old programming operating systems in C is highly impressive. I'm sure there would be people there that would like to meet him.

Offering advice is hard in this regard, because we don't know your sons precise skill level. Clearly advanced, but where is he in math? Does he understand design patterns? Has he learned about system architecture? How much code is he just copy and pasting (nothing wrong with that btw)?

Computer science and programming is actually a very broad subject. It's akin to asking what kind of a doctor you may want to be - there's a ton of different specializations etc.

For operating systems get him this book - Operating Systems Concepts. It's used by most universities, and takes a deep dive into how operating systems work. Highly regarded.

He should also read Design Patterns: Elements of Reusable Object-Oriented Software. It teaches common programming paradigms. This book is considered essential reading in our industry.

He should read Clean Code, and Clean Architecture. Both are written by Robert C. Martin (referred to as Uncle Bob). Uncle Bob is a legend in the industry.

Those are just the standard reading. If he has specific interests then I might be able to make further recommendations.

Lastly, your son should be studying Calculus, Linear Algebra, Discrete and Finite Mathematics. Again, you will want to talk to a university so they can better gauge his skill level.

All of that said - yes he should go to college. He's clearly bright, and he will flourish there. Best of luck to you!

Design patterns like for programming? Or patterns used in visual design systems? Something else?

For the first, there's tons of books out there, a couple I like:

1. https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
2. https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

I've been writing software for 20 years. I think these books are great and would be very helpful in giving you a great head start.

"The Pragmatic Programmer, 20th Anniversary Edition" - https://pragprog.com/titles/tpp20/

"Clean Code" and "Clean Architecture" by Robert Martin - https://www.amazon.com/Robert-C-Martin/e/B000APG87E/ref=dp_byline_cont_book_1

"Design Patterns" - https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=asc_df_0201633612/?tag=hyprod-20&linkCode=df0&hvadid=312280575053&hvpos=&hvnetw=g&hvrand=1840586338880691002&hvpone=&hvptwo=&hvqmt=&hvdev=c&hvdvcmdl=&hvlocint=&hvlocphy=9013682&hvtargid=pla-395340045790&psc=1

How to write good code:

• The Pragmatic Programmer
• Clean Code
• Design Patterns

Working in the software industry:

• Joel on Software
• Cracking the Coding Interview

For a fundamental understanding of how computers actually work (highly recommended):

• Code
• The Elements of Computing Systems

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
https://www.amazon.com/Timeless-Way-Building-Christopher-Alexander/dp/0195024028/
https://www.amazon.com/Pattern-Language-Buildings-Construction-Environmental/dp/0195019199
https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599
https://www.amazon.com/Refactoring-Patterns-Joshua-Kerievsky/dp/0321213351
http://wiki.c2.com/?CategoryPattern
http://wiki.c2.com/?PortlandPatternRepository

> For example, how would I know if I should design something as an object or function? What should I run as separate threads, and how do I figure these things out on my own?

These questions, and some more like these, don't have exactly right answers, even though there can be extremely wrong ones. In reality, what you find is that there are reasonable answers to these questions and they usually depend on context.

Having practice projects help. Build your own stuff. However, just going around doing your own things without looking at what others did isn't that smart. Reading other people's code is an interesting idea. Some books are also helpful here, but don't expect miracles. SICP (https://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871/) really helped me with some of the issues I believe you're having. Maybe you can benefit from reading the gang of four design patterns book (https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/). There are books about design and implementation of particular systems. For example:

• https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997/
• https://www.amazon.com/Design-Implementation-FreeBSD-Operating-System/dp/0321968972/
• https://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388/
• https://www.amazon.com/Database-Design-Implementation-Data-Centric-Applications/dp/3030338355/
• https://www.amazon.com/Retargetable-Compiler-Design-Implementation/dp/0805316701/
• https://www.amazon.com/Modern-Compiler-Implement-Andrew-Appel/dp/0521607655/
• https://www.amazon.com/Engine-Architecture-Third-Jason-Gregory/dp/1138035459/
• https://www.amazon.com/Design-Implementation-3D-Graphics-Systems-ebook/dp/B00918NP90/
• https://www.amazon.com/gp/product/0130319953/

There are more, of course, and some of these are not so great (although still helpful and, usually, much better than what you'd find in "random blog posts in the web").

In general, I believe one of the best way to learn about what you want to learn is to go look at what others did. How did people solve the problems they had in building software system X? Start filling in for X and doing your own research. X could be linux, windows, google chrome, google search software, google translator, adobe photoshop, matlab, R, Eclipse, and so forth. You may not find much for some X, but you'll actually find a bunch of stuff about for several very interesting X.

Another tip here is to pick a problem domain and see what problems people are trying to solve there. I mean, leave "general programming" and start looking at more specific stuff like numerical methods, image processing, AI, game development, bioinformatics, embedded computing, computational statistics, simulations, etc. Find one or two of these subjects that are of interest to you, follow some important people in the field, see what is going on there. You'll find that "design methods" and also "resource usa optimization methods" can vary drastically from field to field, for very good reasons. There are some subcategories in these, by the way. For example, 2d versus 3d game development; single player versus multiplayer (multiplayer can be online or not), etc. In AI there are the deep learning people, the rule based systems people, etc. Numerical methods is huge. There are tons of these. Although you can learn quite a lot on the "general programming techniques" side, there is only so much there. A lot of the interesting things is context specific.

It's alright to feel like this right now, don't be afraid, study more and you will get there.
I strongly believe that the following resources will help you in your quest:

https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612

https://www.dofactory.com/net/design-patterns

https://sourcemaking.com/design_patterns

https://www.oodesign.com/

https://gameprogrammingpatterns.com/ that baroquedub1 already mentioned

You could take a look at decoupling code using Extenject (ex zenject)

https://github.com/svermeulen/Extenject