Best computer science books according to Reddit

Reddit mentions of Design Patterns: Elements of Reusable Object-Oriented Software

Sentiment score: 27
Reddit mentions: 49

We found 49 Reddit mentions of Design Patterns: Elements of Reusable Object-Oriented Software. Here are the top ones.

    Features:
  • The space mouse compact was developed to deliver an intuitive, effortless and precise 3D navigation in CAD applications that cannot be experienced by using a standard mouse and keyboard.
  • Six-degrees-of-freedom (6Dof) sensor - intuitively and precisely navigate digital models or views. Operating system - Windows 10, Windows 8.1, Windows 7 SP1,Apple macOS 10.14, Apple macOS 10.13, Apple macOS 10.12, Apple OS X 10.11, Apple OS X 10.10. Linux Red Hat Enterprise Linux Workstation 4, 5, Linux Novell SUSE Linux 9.3, 10, 11
  • Each of the space mouse compact's two buttons opens its own 3Dconnexion radial menu. They provide direct access to up to 8 of your favorite application commands.
  • With its iconic, pure design, the space mouse compact is small enough to fit on every desk while the brushed steel base ensures the device stability for precise 3D navigation.
  • 2-Year manufacturer's warranty
Specs:
Release dateOctober 1994
#18 of 1,900

idea-bulb Interested in what Redditors like? Check out our Shuffle feature

Shuffle: random products popular on Reddit

Found 49 comments on Design Patterns: Elements of Reusable Object-Oriented Software:

u/hell_onn_wheel · 13 pointsr/Python

Good on you for looking to grow yourself as a professional! The best folks I've worked with are still working on professional development, even 10-20 years in to their profession.

Programming languages can be thought of as tools. Python, say, is a screwdriver. You can learn everything there is about screwdrivers, but this only gets you so far.

To build something you need a good blueprint. For this you can study objected oriented design (OOD) and programming (OOP). Once you have the basics, take a look at design patterns like the Gang of Four. This book is a good resource to learn about much of the above

What parts do you specify for your blueprint? How do they go together? Study up on abstract data types (ADTs) and algorithms that manipulate those data types. This is the definitive book on algorithms, it does take some work to get through it, but it is worth the work. (Side note, this is the book Google expects you to master before interviewing)

How do you run your code? You may want to study general operating system concepts if you want to know how your code interacts with the system on which it is running. Want to go even deeper with code performance? Take a look at computer architecture Another topic that should be covered is computer networking, as many applications these days don't work without a network.

What are some good practices to follow while writing your code? Two books that are widely recommended are Code Complete and Pragmatic Programmer. Though they cover a very wide range (everything from organizational hacks to unit testing to user design) of topics, it wouldn't hurt to check out Code Complete at the least, as it gives great tips on organizing functions and classes, modules and programs.

All these techniques and technologies are just bits and pieces you put together with your programming language. You'll likely need to learn about other tools, other languages, debuggers and linters and optimizers, the list is endless. What helps light the path ahead is finding a mentor, someone that is well steeped in the craft, and is willing to show you how they work. This is best done in person, watching someone design and code. Also spend some time reading the code of others (GitHub is a great place for this) and interacting with them on public mailing lists and IRC channels. I hang out on Hacker News to hear about the latest tools and technologies (many posts to /r/programming come from Hacker News). See if there are any local programming clubs or talks that you can join, it'd be a great forum to find yourself a mentor.

Lots of stuff here, happy to answer questions, but hope it's enough to get you started. Oh, yeah, the books, they're expensive but hopefully you can get your boss to buy them for you. It's in his/her best interest, as well as yours!

u/asdff01 · 11 pointsr/AskComputerScience

The book that allowed me to do this is the legendary "Gang of Four" Design Patterns book. Code examples are in C++ and it was written a while ago, but is still recommended as a fantastic resource for learning how to design software well.

There is also the SOLID principles, for object oriented design.

u/Jumballaya · 10 pointsr/FreeCodeCamp

> Felt pretty good about myself.. until I got to the algorithm section.

This is VERY normal. These are hard math concepts that take everyone a little bit to get used to. The only way you will learn these concepts is by implementing them, over and over and over and over and over.

> I would say I was getting stuck probably about half the time and would turn to read-search-ask method.

If this were not the case, then there would be no need to learn. I am a web developer and I look up the most inane shit on a daily basis because it is something that I either have never used/implemented or something I rarely use/implement (my big one here is PHP's array functions, I can never remember if the array comes before the callback or not with array_map() but I remember that it is the exact opposite of array_filter() and array_reduce()). Embrace this, build your Google-fu because you will always need it.

> A lot of times I was missing some small operator (code error) or somewhat minor step in the thought process, other times I would be lost entirely. Basically I wasn't thinking about how to implement my code well enough, imo.

This is 100% normal. Have you ever heard of a code review? This is where other developers review your code before it goes live. The point of this is that you cannot be 100% perfect with your code, maybe you forgot a semicolon or maybe your code is tough to read, that is what the code review process is like. I write code in iterations to make sure that I never 'get in too deep' and the fear of removing code sets in, each of these phases I go through a mini code review to see what is working at what isn't. I ALWAYS find some half-baked logic in my first few iterations before I really get into it and over the last couple years I find that I need fewer and fewer iterations and that I am able to get a better 'big picture.'

Don't be afraid to scrap some code and go back at it, this is your education and only you know when you understand the material. I have a bajillion abandoned side projects and so does every developer that I know.


Advice


  1. Keep coding, it is the only way you are going to get better, for real.
  2. Read other people's code. This is where I learn all my cool tricks; Anytime I find a cool project/library/framework I hit up github and read through as much of the source as I can stomach. You will be surprised at how much you learn about the parts of a project that AREN'T code like documentation, contributing, comment styles, things that seem secondary when first learning to program.
  3. Design patterns, paradigms, data structures, algorithms. I wouldn't suggest going head-on with this stuff yet, but don't be afraid of it. Design Patterns Book (Gang of Four) - This is a very highly suggested book, though the examples are in C++
  4. Learn another language. The largest increases in my JS knowledge have come from learning another language and bringing back that language's way of thinking into JS. I would suggest Python because it is stupid-easy to jump in and start making cool stuff, but any language will do. Python, Java, C#, PHP, Elixir, Ruby, C++ and Go are a handful I can think of that will aid in employment as well as teach you new ways of thinking about JS.
  5. Talk to developers, go to meetups, scour github for misspellings in documentation and contribute. Anything that you can do to get a free mentor will be an AMAZING boon for you


    Links

  6. Project Euler - Looking for something to code? Here is around 600 different problems to solve. I am pretty sure some of the FCC algorithms were taken from Project Euler as it is a very good resource.
  7. Eloquent JavaScript - A great resource, though, a little dated
  8. You Don't Know JS - Another great resource on the JavaScript language. I reread through these books every once in a while.
  9. Professor Frisby's Mostly Adequate Guide to Functional Programming - Great primer on functional programming with JavaScript
  10. Rosetta Code - Algorithm reference across many languages, though, the coding style for each tends to be a mess it is a good getting-started reference.
  11. 2017 Frontend Handbook - This is great for figuring out what to learn next when you get to that point where you don't know what to learn next.


    I did FCC up through the frontend section, I started my web dev career path in 2014 and picked up FCC in mid 2015 right before getting a job in web development. The most important part of FCC is that you are coding, getting practice and making mistakes, TONS of mistakes. Just keep it up, don't get burned out and remember that it is about your education, not how many challenges you complete. Code and read and read code.
u/cemremengu · 7 pointsr/csharp

Those who want more detailed info on these should check the Design Patterns book by GOF

Link:
https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8

u/dear_glob_why · 7 pointsr/javascript

There's more than a single design pattern for applications. Recommended reading: https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented-ebook/dp/B000SEIBB8

u/myrrlyn · 6 pointsr/learnprogramming

>How did you learn this?

With a Computer Engineering degree and a friend in Comp Sci I could pester.

Here's some of my reading list:

u/Obie-two · 5 pointsr/learnprogramming

the book is just called "Design Patterns?"
This?

u/invictus08 · 5 pointsr/cscareerquestions

I will suggest start with Head first design pattern. That will gradually build your intuition about good software design. And it’s more fun to read compared to GoF imo. On top of that, there are Youtube videos by a guy named Christopher Okhravi on design patterns. Since I understand much better with videos (along with text book) because of my attention deficiency, they really helped me.

Apart from that, follow tech blogs of Netflix, Google, AWS, Uber etc. They are treasure troves.

Also, as /u/ibsulon mentined, Clean Code for writing good quality code, Programming Pearls and Pragmatic Programmer etc. Effective java and Doug Lea's book on concurrent programming - really helpful.

u/-jp- · 5 pointsr/java

Learning JavaScript is pretty good advice since it's useful in its own right, but honestly any company that expects a Jr. Java developer to have any kinda deep insight is being just unreasonable, and probably isn't a very good place to work. Everybody starts somewhere, Java developers included.

That said, for anyone wanting to learn design patterns, I suggest the classic GoF book: Design Patterns: Elements of Reusable Object-Oriented Software.



Just.

Please.

Promise me if you read it you won't use Visitor for anything ever.

u/Shark_Kicker · 4 pointsr/javascript

FFS... just stop. This is NOT a Mediator Pattern

Three articles that are either partially or completely wrong in three days? Just. Stop. Go get this book... read it... then try again.

You can't just "invent" patterns and name them after existing patterns because you named one of your objects "mediator".

A Mediator Pattern in JS explained by someone who knows what he's talking about

u/ZioYuri78 · 4 pointsr/unrealengine

I have the first edition and yes, it worth a read, keep in mind that it explain how game engines works and not how to make a game engine.

After reading it you will not be a master with UE4 but you will undertstand why UE4 do things in a certain way.

Another book you have to read (and is mentioned in your link) is the Game Programming Patterns book, i have the physical copy and it is awesome, read it after the GoF Design Patterns book, is a masterpiece combo.

EDIT:

Also two sites i want to suggest:

Learning Modern 3D Graphics Programming, is a great tutorial about OpenGL basics.

The Book of Shaders, great to learn how shaders works.

u/illithoid · 4 pointsr/salesforce

I'll be honest with you, I don't think Head First Java would be a good choice, however DO READ Clean Code. I also suggest Design Patterns: Elements of Reusable Object-Oriented Software and Working Effectively with Legacy Code. The first is a classic MUST READ for anyone in software development. It present numerous challenges that most of us will face when developing solutions, and gives you the design patterns you will need to solve them. The second is great for learning how to fix your predecessors shitty code, you'll need this one. If you haven't already, look up Bob Buzzard and Andy Fawcett. These two guys are my favorite SFDC Dev Bloggers. I also suggest watching any Salesforce Webinar that has anything to do with code, especially security stuff.


Practice makes perfect, except for us there is no perfect, just better. Know your best practices and live by them. With everything you do ask how can I make it better? Faster? More efficient? Do I even need code, or will Workflow/Process Builder/Flow do? How can I write code, so that an Admin can customize it without any code?

> Based on code reviews--my code is pretty good, with good logic and pretty well laid out.

This is actually VERY important, having good logic is obviously crucial, but being well laid out is a kind of hidden requirement with code. You or somebody else will eventually need to maintain your code, if it's laid out well it should hopefully be easy to read and maintain.

When you write code do your best to incorporate declarative features so that further customization can be done without code (I know I said this earlier, but I think it's important). Need to write some code that uses an arbitrary set of fields, consider using Field Sets. An Admin can add/remove them without code. Maybe use a Custom Setting, or Custom Metadata to map fields to values.

Learn how to use Describe calls for everything. Need to write some code that catches dupes and merges them? Don't hard code the values, then nobody will be able to remove or add fields without updating code. Instead use Describe calls, now you get every field on the object forever. Need to remove a field from an object no problem. Need to add a field to an object no problem. Does your losing record have child records that need to be reparented? Don't hard code, use Describe calls to get all sObjects with a Child Relationship. Use Describe to find out if it can be directly reparented or if it needs to be clones (CampaignMembers can't reparent a LeadId to a new Lead. You MUST clone and add the new Lead Id).

How much do you know about HTML? CSS? JavaScript? JQuery? Visualforce? Learn 'em. Lightning is coming, and these are going to be more important than ever (except maybe Jquery).

Practice, practice, practice. One coding assignment per month isn't that bad, but if you get some work done early and you have an hour or two to spare, work on a side project. Can you think of something in your company that could be automated, spin up a Dev Org and give it a shot. Maybe your Sales people could use a new VF page for entering information just a little quicker.

Always seek to improve your code. Always seek new ideas and better ways of doing things.

Trailhead is good, do all the coding ones you can find, it's more practice!

u/soundslikeponies · 4 pointsr/programming

You can always read books. Textbooks are much better to read when you're free to browse and pick out whichever ones you like. You can get a surprising amount of reading done just by reading on the bus, on the can, and whenever you've got nothing better to do.

A popular stack overflow answer has a pretty good list. You can preview the introduction of most books on amazon.

People like to champion the internet as "oh, you can learn anything on the internet!" Which is true. But you can learn it much faster and better from a book (generally speaking).

Books provide a long format which has a chance to build upon itself. Also, everything is collected in one place for easy access. More developers ought to sit down and read good books.

u/Kaelin · 4 pointsr/compsci

Study design patterns and read books by the masters.. Find the books that are recognized by the community as "the best". For example "Effective Java" is one of the best books on writing Java beyond the basics.

The Pragmatic Programmer: From Journeyman to Master


http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&ie=UTF8&qid=1374154408&sr=1-1&keywords=pragmatic+programmer

Design Patterns


http://www.amazon.com/Design-Patterns-Elements-Object-Oriented-ebook/dp/B000SEIBB8


http://www.amazon.com/gp/product/020161586X/ref=oh_details_o05_s00_i00?ie=UTF8&psc=1

u/in0pinatus · 4 pointsr/rails

Despite the title, this isn't the Design Patterns[1] State Pattern.

In the State pattern, a context object (such as an order) changes its behaviour by delegating all state-specific methods to another object that implements the behaviours for that state. When the state is changed, the context object switches to using another state object - which will have the same interface, but the implementation is state specific.

So, taking the example in this article, an Order object chooses between state objects of Order::State::Cart, Order::State::Cancelled etc. It then delegates business methods like "add item", "refund", or "ship it" to the state objects.

This takes care of the expectation that an order still in the shopping cart state behaves differently to a cancelled order, but without having Order fattening itself with all the knowledge required.

So as a refactoring this is helpful in opening up a context object for extension without bloat, by localizing and partitioning that state-specific behaviour; there are other benefits besides[1].

What the State Pattern isn't: a nice DSL to describe your state machine's states and transitions and callbacks. That's definitely a utility offered by state machine gems, but labelling it the State Pattern is off in the weeds and missing out on the real OO refactoring.

[1] Design Patterns; Gamma/Helm/Johnson/Vlissides, 1995. pp305-313

u/nanojava · 4 pointsr/cscareerquestions

Most of the design patterns introduce by GOF (gang of four) is still applicable today. Buy and read this book

u/casualblair · 3 pointsr/learnprogramming

Skill - if you look at a book and can't even figure out what the topic is about then it's too advanced. EG: Entity Framework - if you don't know what an ORM is or why it would be a good idea to have a DAL then you might want to skip this and come back later.

Find a popular blog or podcast on your topic then browse through their articles and notes. They should be regularly recommending books or sites that are useful. Then take that book and google other sites for it. Find lots? Good book.

And yes, amazon reviews do matter. EG:

https://www.amazon.ca/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8

4.4 out of 5 stars, only one version ever published, and all the negative reviews are about the kindle version, and it's basically THE book for learning design patterns, even 20 years later.

u/nutrecht · 3 pointsr/java

Although I admire the optimism for a lot of people here I feel they are not being very realistic. Like the mention of using sales experience to 'sell' yourself to employers: it's fine and dandy if you can bullshit your way into a job but if you can't actually deliver you'd be 'let go' within a month.

Learning a language is just one aspect. What's most important is doing actually a ton of programming. So make sure you have at least 3 moderately big projects with good code quality that follow best practices that you can show to employers.

Feel free to hop over onto /r/javahelp to have us review your code and suggest improvements. Being a developer isn't really about languages: it's about turning a customer's problem into a working solution. That's the hard part.

One last tip: for someone without any CS education but who is going into an area where OO skills are a must this book is a must read: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented-ebook/dp/B000SEIBB8

Heck. Showing an employer that you read and understand it and apply it in your projects would give you a huge head up.

u/TNMattH · 3 pointsr/csharp

>Is there any decent books on the GoF stuff?

The GoF book: Design Patterns: Elements of Reusable Object-Oriented Software by "The Gang of Four" (Gamma, Vlissides, Johnson, and Helm)

u/BertilMuth · 3 pointsr/learnjava

It will certainly take time. How long is hard to say. One thing is being exposed to code, and writing code yourself. Another thing is actually collaborating with people that are more experienced - that helped me a lot. An eye opener in my coding journey was the "Gang of Four" design patterns book (https://www.amazon.de/dp/B000SEIBB8/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1). The risk is that you will overdo design patterns at first, but that will hopefully settle :-)

u/YuleTideCamel · 3 pointsr/learnprogramming

Software Architecture is a nebulous term that can mean different things to different people. I'm a software architect and there is no single definition for architecture.

Instead try to get a deep understanding of good programming concepts and patterns, while focusing on ways to scale both your application and resources. Introducing unit testing, continuous integration and industry best practices is a key part of good architecture.

Architecture is also more than just the technical side, it's understanding the business domain and making decisions based on that.

tl;dr figure out what architecture means to your business and find the best way to bring value from a high level.

The following books are good resources:

u/patroniton · 2 pointsr/AskProgramming

Clean Code can probably help somewhere.

Do you know any Software Design Patterns? They are more of what you are looking for I think. Design Patterns are a way to structure your code so that you don't repeat yourself, keeps code understandable since it follows guidelines from the pattern.

Head First Design Patterns is probably a good place to start with that, and once you understand the basics I would recommend you read the highly recommended Gang of Four (it's nicknamed because of the four authors).

u/ell0bo · 2 pointsr/PHP

Well, I generally don't buy PHP specific books, so this book doesn't really talk about PHP, however a lot of the design patterns can be transfered over. I thought it was a very good book: Design Patterns: Elements of Reusable Object-Oriented Software

Another one that's not completely about OOP, but is PHP :
Real-World Solutions for Developing High-Quality PHP Frameworks and Applications

u/ChrisAAR · 2 pointsr/AskComputerScience

I would recommend reading this book: https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook-dp-B000SEIBB8/dp/B000SEIBB8/

Extremely useful concepts to have and understand. I love the use-case the book uses (a portable, rich text editor) as a way to teach you what patterns to use (and not to use). I'm 8+ years in industry and I find coming back to it extremely helpful.

It's my want-to-be-productive-while-on-my-phone go-to book. IMHO definitely more worth it than reading a "coding" book and not having a machine to try it out (I find reading about coding without doing coding to be non-productive, at least for me).

u/Mekire · 2 pointsr/pygame

Well, I pretty much hate it, but if you really wanted to you could pre-plan your projects using UML. You can find some free UML editors online if you look. ArgoUML is okay, but definitely needs improvement (like an undo feature).

Also if you are interested in programming patterns, the canonical text is the GoF book. If you search I'm sure you will be able to find a PDF version of it. There is also a website dedicated to talking about the same book in terms of the application to games:
http://gameprogrammingpatterns.com/contents.html

u/JohnKog · 2 pointsr/compsci

A lot of good mentions here. Although they're more programming and engineering than "computer science", I would add Design Patterns by the Gang of Four, and
Programming Pearls by Jon Bentley.

u/jj2parkie · 2 pointsr/manga

Probably. It might take some refractoring, but you would need a SaaS like Parse to handle the cross platform sync. I never tried Parse, but I don't want to since it costs money after a certain quota. I've heard some horror stories of independent developers messing up their Parse and blowing through their quota as they failed to put a kill-switch.

Same. I started this project around November to learn Android development. I have a year off before I start college, so I thought of learning some software development. My only experience at the time was high school computer science using C#, so even if you are learning you can contribute. :) Even if it's intimidating you can contribute by submitting issues and such. I contributed to a small database library which was over my head, but I browsed the source to find out how to do something, found an typo in the SQL, and submitted an issue explaining the problem and how to fix it: he forgot a letter.

Although I started learning programming in 2014, if you need any advice on learning Android development, you can PM me. I can provide a list of books you can find online which are helpful for learning Java:

  • Effective Java

  • Advanced Topics in Java

  • Clean Code

  • Design Patterns


    All these books are sectioned such that you only need to read parts you want to, so they are very good references. These books really helped in knowing the syntax of a language and knowing how to use the language which I found was very important for a project of this scale. My first version of it was so hacked together that it was impossible to refractor to add new features. These books really helped for the second version even though I couldn't apply what the books advised effectively.
u/barthooper · 2 pointsr/csharp

In the past couple of weeks, I've been reading Design Patterns: Elements of Reusable Object-Oriented Software. If you understand MVC and design patterns in general, it is a good reference. The bulk of the book consists of the design patterns catalog, but there's also a chapter that lays out the reasons for using patterns in broad strokes, as well as a case study involving reasons for applying multiple design patterns in a project.

More than just describing the patterns themselves, some of the book focuses on the interrelationships among different design patterns. As a caveat, it references C++ and Smalltalk in its code samples, but the concepts of structuring objects and their dependencies transcend languages.

u/Nciacrkson · 2 pointsr/iOSProgramming

Really? I've always associated big-4/gang of 4 with this book

u/cyancynic · 2 pointsr/iOSProgramming

I think if you haven't read the GOF Patterns book, and then gone through the Cocoa apis and spent some time "pattern spotting", then you're probably not really a professional grade developer.

When "Patterns" came out, there had never been a systematic approach to describing common software abstractions or how they solve various problems. We call it "software engineering" but it is usually practiced more like software carpentry.

OTOH, mechanical engineers have been able to draw on references like 507 Mechanical Movements since the mid 1800's.

u/DarkCrusader2 · 2 pointsr/Python

Try this. I heard it's quite good. I am going to start this one myself in a couple of weeks.

u/dmazzoni · 2 pointsr/learnprogramming

> I learned in android studio and got to a level where I could create an app. Little did I know, it was just a giant main activity with 100s f methods. My friend looked at the code and told me I needed to learn polymorphism. Now I've redone the code so it's all inclasses.

Yep. This is a really common stage in learning. It sounds like you maybe went overboard and created way more classes than you needed.

Next time I might suggest starting with your working program with just one big activity, then splitting things into separate classes one at a time.

> Well, I have to keep updating a bunch of list sizes to the main activity, but the problem is that the polymorphism has the list sizes passing through 4 classes to get to the main activity. So, I set up a bunch of interfaces that react when things are done within the classes all encapsuled in one overreaching class. I don't know.

I think you're blaming "polymorphism", but polymorphism is just a tool. You can use it to make good designs or bad designs. It's quite easy to use it to design something that's cumbersome and less effective than if you had no classes at all, and it sounds like that may have happened here. It doesn't mean there's something wrong with polymorphism.

I think you're conflating two separate things here: (1) what's a good design, and (2) how do you make your code work.

(2) is easy. If you post a small, complete program that doesn't work, we can help you understand why. We can't do that if you just post vague questions and snippets of code.

(1) is hard. This takes years to get the hang of, and a lifetime to master. At a good software company you'd learn this slowly by mentorship - you'd have a senior programmer reviewing every change you make and guiding you through the design one feature at a time. You'd get help organizing your code long before it got to hundreds of functions.

If you don't have that option, or even if you do, I'd recommend the book Design Patterns as a way to better understand how to use polymorphism effectively.

You're also welcome to post such questions here, but they have to be very specific. You have to tell us what your app does, in a lot of detail, and how you've organized it into methods. I can't give you advice on something vague like "passing list sizes to the main activity" because I don't understand the purpose of the lists, the purpose of the sizes, or the purpose of passing them to the main activity.

u/Toast42 · 2 pointsr/webdev

I've found data structures more useful than algorithms. This book is highly rated and imo a must read for all programmers.

https://www.amazon.com/Design-Patterns-Object-Oriented-Addison-Wesley-Professional-ebook/dp/B000SEIBB8

u/UmbraVeil · 1 pointr/AskComputerScience

Haven't read it yet, but I believe the "Gang of Four" is somewhat of a standard for learning design patterns.

u/flavian1 · 1 pointr/sandiego

> I've seen design patterns as a topic mentioned numerous times before; do you have any good recommendations for resources on the topic? Do they tend to be focused on the language used or are they more general concepts?
>

the 'bible' of design patterns is the book by the gang of four: http://www.amazon.com/Design-Patterns-Elements-Object-Oriented-ebook/dp/B000SEIBB8

design patterns are just that...patterns. they're high level strategies to use for particular situations. Look through /r/programming and that should lead to other web resources.

u/HiRezWeiss · 1 pointr/Smite

Sticking to specific design principles in code is a recipe for pain. It's easier to adapt to pre-existing style in the case of something like UE3 than it is to adapt UE3 to specific design principles. While it's certainly good to be familiar with common patterns (Design Patterns and Code Complete are two of the more common books I see in this regard), being flexible and ready to adapt to a pre-existing code style is going to be infinitely more useful.

In that situation, you're still going to learn more on the job than in school, and that's hard to avoid.

u/programatorprogramer · 1 pointr/serbia
u/Kaiser214 · 1 pointr/webdev

Most people don't have the stomach to read books like this.

u/netherous · 1 pointr/learnprogramming

Not much to go on. Let's try this.

Do you understand the notion of decomposition? A well-organized program will have many functions, each of which does one thing and does it well. The higher level functions will use these as a toolkit to orchestrate more complex tasks. A program organized in such a way is easier to continue adding to even as it grows large.

Let's have an example. You have made the following lower-order functions in a hypothetical game, each of which does exactly what they advertise:

advanceToNextTurn
setPlayerMaxHealth
setPlayerSpriteGraphics
playSoundEffect

These are simple functions. Now let's make a function that uses them as a toolkit to accomplish a larger task. Let's turn the player into a werewolf.

def changePlayerIntoWerewolf():
setPlayerMaxHealth(player.currentHealth * 1.2)
setPlayerSpriteGraphics("sprites/werewolf")
playSoundEffect("audio/werewolf/howl.flac")
if(player.movementPoints < 1.0):
advanceToNextTurn()

Let's make an even higher-order function that uses this one.

def advanceMoonPhase():
if(moon.phase == 0): # full moon
if not player.inWerewolfForm:
changePlayerIntoWerewolf()
else:
if player.inWerewolfForm:
changePlayerIntoHuman()

Regarding your Roguelike - it's pretty simple as it is. I'm not sure what kind of trouble you have with it. A few hundred lines of code in a few files is not a complex program. You might consider rethinking some of the parts in terms of more stringent modelling of the game elements (for instance, shouldn't you have a Map class with all of the map data and information about which Being is standing where? Your movement methods might take the current game Map as an argument).

Books are always nice. Reading code is important, and there are many good books with excellent examples.

u/CasualFrydays · 1 pointr/ProgrammerHumor

So I mostly taught myself programming, but i have an engineering background. For context, im working now as a game developer. What i found most helpful once i became confident with my actual problem solving skills in programming was learning programming patterns.

For me that came in the form of [this book] (https://www.amazon.ca/dp/0990582906/ref=cm_sw_r_cp_apa_fSt.Bb1A7WQ5E), which is really just a rehash of how the design patterns in this book can be applied to game development.

Basically once you're more familiar with design patterns, you'll be able to build more manageable code, and better understand others who are using the same patterns.

u/dead_pirate_robertz · 1 pointr/csharp

The book is still in its first edition. From the Editorial Review on the Amazon page:

> The CD-ROM works with any Java-enabled browser (Internet Explorer 4.0 and Netscape Communicator 4.0.) It includes the full text of the printed book along with the richness of hypertext links to get the most out of patterns quickly. (Two versions of the text, one for 640 x 480 resolution and one for higher resolutions, are provided.)

It's friggin' old.

Everything else changes continuously in software. It's hard to believe that there aren't a bunch of design patterns that the GoF missed or have been invented since the GoF book was written.

u/jpiascik · 1 pointr/learnprogramming

One of the best books to own on design patterns is the GOF or "Gang of four" book. But be warned, this is not light reading, so I like to keep it for reference and use this site as a faster way to find the pattern I need. It's a less intimidating and more convenient resource for wading into the GOF patterns. SIDENOTE: I'm not a microsoft developer!

u/bigdubb2491 · 1 pointr/cscareerquestions

If you're relatively new to OOD and OOP, I'd look into the Head First books. They do a great job cutting ones teeth on the topics. If that's too rudimentary for you then the GO4 book on reusable design patterns. This is the bible on design patterns for Software Engineers. As for SOLID There is a smattering of information. Basically this consists of five principles:

  • Single Responsibility classes
  • Objects are open to extension but not modification
  • Liskov substitution principle, In a nutshell objects that inherit from other objects should not have less functionality than the objects from which they inherit.
  • Implementation of interfaces
  • Dependency Injection.

    There's a smattering of information around the web. That should be enough to get you started.

    As for implementation. One thing I've done in the past is to take a simple programming exercise, e.g. FizzBuzz and see if you can't write a solution that implements SOLID. so you can create different rules via extension. Things like that.
u/nwilliams36 · 1 pointr/learnprogramming

[Design Patterns] (https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented-ebook/dp/B000SEIBB8) old but still good for understand OO structures

u/PreExRedditor · 1 pointr/cscareerquestions

design patterns are language agnostic, so it shouldn't matter which language a book opts to teach in. this book is generally regarded as a paramount resource in learning design patterns