#10 in Books
Use arrows to jump to the previous/next product
Reddit mentions of Design Patterns: Elements of Reusable Object-Oriented Software
Sentiment score: 128
Reddit mentions: 217
We found 217 Reddit mentions of Design Patterns: Elements of Reusable Object-Oriented Software. Here are the top ones.
Buying options
View on Amazon.comor
- Great product!
Features:
Specs:
Color | White |
Height | 1.04 Inches |
Length | 9.31 Inches |
Number of items | 1 |
Weight | 1.9510910187 Pounds |
Width | 7.62 Inches |
Here's my list of the classics:
General Computing
Computer Science
Software Development
Case Studies
Employment
Language-Specific
C
Python
C#
C++
Java
Linux Shell Scripts
Web Development
Ruby and Rails
Assembly
Refactoring: Improving the design of existing code
Design Patterns
Working Effectively with legacy code
Clean Code
How to be a programmer
Then there are language specific books which are really good. I think if you read the above, slowly over time, you'll be in a great place. Don't think you need to read them all before you start.
Here's a list I compiled, the list books kind of hit a wide range. I don't really have any given list of talks I like. I'll just randomly google for videos by a speaker i like or subject I'm interested in.
Books:
Watch:
Podcasts:
Blogs:
News Letter:
Misc:
My bad.
In Object Oriented Programming (OOP), there are lots of design patterns that end up getting repeated all over the place. You might have run in to the factory pattern, or perhaps the builder pattern?
If you can understand and notice these patterns, it means you can re-use old code more effectively, because code to handle a pattern in one place is probably very similar to code to handle a pattern in another.
In addition, if you're discussing a problem with somebody, it means you can refer to the patterns by name as a sort of shorthand notation for "put it together like this". Saying "use a decorator" is a lot quicker and easier than describing what exactly "a decorator" is from scratch every time.
The "Gang of Four" are four Computer Scientists who were among the first few to notice that these patterns kept popping up, and wrote a pretty well known book describing about 20 of the most common ones.
In this specific instance, the builder pattern would probably have proved useful. Rather than having a single, monolithic constructor, you create a separate "builder" class.
Character chararacter = new Character(xx, yy, life, kpph, kpyl, kvin, krak, kgr, kptgr, kbb, havepph, havepyl, havevin, haverak, haveya, isevented, x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, IE)
Can become
Character character = Character.builder()
.life(life)
.initialCoordinates(x1, y1)
...
.build()
This is waaayyy more readable (especially if you're assigning values as arguments, rather than named values. If you ever called createFrom(...) with a string of numbers, it'd be very difficult to work out which number was what), and a lot easier to lay out properly. It also means you can gather arguments for creation gradually over time rather than all at once.
Also looking more closely, and as /u/PM_ME_YOUR_HIGHFIVE pointed out, they're not actually using objects at all, which would be a good place to start.
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
Creo que mucha gente se confunde ser autodidacta con hacer algun cursito de como hacer una web y darle con eso.
Para llegar a cierto nivel, tenes que aprender computer science, teoria y trabajar en cosas que te permitan aplicar esa teoria.
Tenes que saber ver un algoritmo y poder calcular la complejidad, tenes que entender que son las patrones de diseño y cuando conviene aplicar tal o cual.
Tenes que entender como funciona OOP, pero tambien tenes que aprender algun lenguaje funcional, te va a hacer un programador más rico.
Tenes que entender de Unit Testing, automated testing, Integration testing.
Los dos libros que más me ayudaron cuando empecé en computer science son :
https://www.amazon.es/Algorithm-Design-Manual-Steven-Skiena/dp/1848000693
y
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Y ir codeando mientras vas leyendo y aplicando las cosas es fundamental.
Me parece que la diferencia entre ser autodidacta es que no tenés esa vara minima que te da la facultad, asi que depende de vos que tan crack queres ser y si estas dispuesto a poner el laburo y a aprender cosas constantemente.
La información esta en internet o Amazon, no hay ningún secreto.
Edit: these are not affiliate links :)
fwiw, bare minimum working code is often a good idea if we're talking about the amount of code to do some task :)
Design patterns are most useful in that they help you start recognizing patterns in your own code, and they show you a number of common patterns which can be useful - but it's good to keep in mind that you shouldn't force a design pattern somewhere just because it's a design pattern.
Anyway, the Design Patterns book is good, and so is Head First Design Patterns.
I think your major problem here is that you want the "why not"s instead of the "why"s. A good programmer can look at a chunk of code and determine "why" the programmer is doing certain things. These pre-extising code blocks that people refer to are given because you should be able to read through it and interpret what's going on and why. The questions you most likely ask at the "interpreting" stage isn't "why" but instead "why that way and not this way?"
Really, when it comes down to it, the answer as to that question for a lot of things in engine programming (or just programming in general) is that it's what the lead designer or lead programmer thought was the best idea.
For instance: How do you want to store your array of tiles? As integers representing tile indexes in a tile set? As separate Tile class instances in a vector array containing vector arrays of Tile instances? As a hashmap indexed using characters to grab a tile? etc. There's a million ways to handle each and every part of an engine, it all comes down to what design patterns and what theories you think are the best for what you need your engine to do.
I suggest reading up on some of the design patterns in here (actual link in the sidebar) and here. They're a great way to start understanding the multitudes of ways of handling different ideas in your engine! Reading up on pre-existing theory or seeing pre-existing pseudo-code is fine and dandy, but sometimes you have to reinvent the wheel. Sometimes, for the most part you can follow a lot of design patterns that already exist.
P.S. For a great tutorial on loading tile maps and working with them in your game, lazyfoo's got you covered (it's in C++ but can easily be adapted for other languages) Here
I admire your dogged adherence to being wrong in every particular. It takes a special brand of stubborn contrarianism to quote someone's badly edited notes as a primary source and then followup by a claim that this is best possible research.
However, outside in the real world, Alan Kay writes extensively and authoritatively here and in his numerous contributions on Hacker News quite aside from publications spanning decades.
And an awful lot of people agree with his definition. The introduction of the classic Design Patterns defines objects as an encapsulated package that only responds to messages. People who teach OO programming readily quote Mr Kay's definition. The Ruby programming language is fundamentally based upon it, and before you shout "but Ruby has classes" note that Ruby classes are actually themselves objects, for which the
new
message happens to do something particular by convention. And so on; the point being that Alan Kay's definition is super influential, which is why the idea that Erlang is the most object-oriented language is not a new proposition.I'm sort of in the same boat as you, except with an aero and physics background rather than EE. My approach has been pretty similar to yours--I found the textbooks used by my alma mater, compared to texts recommended by MIT OCW and some other universities, looked at a few lists of recommended texts, and looked through similar questions on Reddit. I found most areas have multiple good texts, and also spent some time deciding which ones looked more applicable to me. That said, I'm admittedly someone who rather enjoys and learns well from textbooks compared to lectures, and that's not the case for everyone.
Here's what I gathered. If any more knowledgeable CS guys have suggestions/corrections, please let me know.
Full disclosure: I haven't actually read more than the preface of any of those books. Software engineering topics are more directly applicable to me than CS topics right now, so here are some that I've actually started reading:
Even though this seems to be just aggregating some Stack Overflow answers into blogspam, I'll bite.
> Two lines of code is too many
If you're seriously going to complain about one extra line of code in a method, I don't see this ending well.
> If it's not native, it's not really programming
Semantics. Even if you don't call it programming, you'd damn well better know those things if you want to use them. SQL, Java, and any other VM-based language may not qualify as "programming" by this definition, but they're still damn useful.
> The "while" construct should be removed from all programming languages. (In favor of "Repeat...Until")
Semantics again. There is no functional difference between the two, and I would argue that while is actually preferable since it puts the looping condition right there on the same line, instead of having to skip to the end of the block to find out if you even entered the block in the first place.
> Copy/pasting is not an anti-pattern.
No, it's not, and it's been proven. I'm having a hard time finding the peer-reviewed study on copy/paste programming right now, but basically, it's been shown to save a lot of time as long as you're using it properly.
Where the hatred for it comes in is that, like GOTO, if you use it too often, you'll probably end up using it wrong.
> Developing on .NET is not programming, it's just stitching together other people's code
A reiteration of his 2nd point, but honestly, a huge amount of working as a professional programmer -- hell, almost the definition of working in a team -- is stitching together other people's code. There's nothing wrong with that, and it's hardly controversial.
> The use of try/catch exception handling is worse than the use of simple return codes and associated common messaging structures to ferry useful error messages.
This has been getting debated a lot in go-lang circles, but the general consensus seems to be that unless you're working in an embedded environment (or some other highly-constrained environment), you're probably better off with try/catch.
> Test constantly
Test-Driven Development is something that I personally agree with, and truthfully has become a very popular practice among Rails people. I don't see how that would qualify it as being controversial.
That said, certain studies have shown evidence that TDD is not as effective as many seem to believe.
> Object Oriented Programming is absolutely the worst thing that's ever happened to the field of software engineering.
I've heard this claim semi-often. It seems to mostly come from people having worked with languages that claim to be OO but constantly make exceptions to the rules, like Java, C++, or Python. In fact, the author specifically calls out Java.
Try Smalltalk or Ruby and you'll come to see that OOP done right is actually quite wonderful.
> C (or C++) should be the first programming language
Debatable, but certainly not controversial by any stretch of the imagination.
> Classes should fit on the screen.
How big is your screen? I can fit any class definition on a 64" monitor.
Some classes simply must be large. It is an unavoidable fact that certain things are simply more complex to model than others. This point isn't controversial, it's just asinine.
> Making invisible characters syntactically significant in python was a bad idea
This again? Is it really a controversial opinion if it's been something non-Python programmers have been whining about for decades? Because as far as I can tell, people whine about it for about the first five minutes of Python coding, and then give up because they would've been indenting anyway.
It can cause bugs when transferring code between computers, I'll give them that. Otherwise, it's Python demanding good formatting, something that you should be demanding from everyone on your team anyways.
My main regret with Python is that I haven't found a good tool that auto-formats everything (a la "gofmt").
But otherwise, Python's indentation requirements are so in line with common indentation in almost every programming language that proper indentation comes naturally to more or less everyone. In how many programming languages that you regularly use do you not format your conditional, looping, class/method, or exception blocks?
> Singletons are not evil
It's not controversial to agree with Design Patterns. That book is more or less the undisputed truth on the subject, and it thinks the Singleton pattern is fine and dandy.
You have a long journey ahead of you, but here goes :D
Beginner
C++ Primer: One of the better introductory books.
The C++ Standard Template Library: A Tutorial and Reference: Goes over the standard template library in fantastic detail, a must if you're going to be spending a lot of time writing C++.
The C++ Programming Language: Now that you have a good idea of how C++ is used, it's time to go over it again. TCPPL is written by the language's creator and is intended as an introductory book for experienced programmers. That said I think it's best read once you're already comfortable with the language so that you can full appreciate his nuggets of wisdom.
Intermediate
Modern C++ Design: Covers how to write reusable C++ code and common design patterns. You can definitely have started game programming by the time you read this book, however it's definitely something you should have on your reading list.
C++ Templates: Touches on some similar material as Modern C++ Design, but will help you get to grips with C++ Template programming and how to write reusable code.
Effective C++: Practical advise about C++ do's and dont's. Again, this isn't mandatory knowledge for gamedev, but it's advice is definitely invaluable.
Design Patterns: Teaches you commonly used design patterns. Especially useful if you're working as part of a team as it gives you a common set of names for design patterns.
Advanced
C++ Concurrency in Action: Don't be put off by the fact I've put this as an "advanced" topic, it's more that you will get more benefit out of knowing the other subjects first. Concurrency in C++11 is pretty easy and this book is a fantastic guide for learning how its done.
Graphics Programming
OpenGL: A surprisingly well written specification in that it's pretty easy to understand! While it's probably not the best resource for learning OpenGL, it's definitely worth looking at. [edit: Mix it in with Open.gl and arcsynthesis's tutorials for practical examples and you're off to a good start!]
OpenGL Superbible: The OpenGL superbible is one of the best ways to learn modern OpenGL. Sadly this isn't saying much, in fact the only other book appears to be the "Orange Book", however my sources indicate that is terrible. So you're just going to have suck it up and learn from the OGL Superbible![edit: in retrospect, just stick to free tutorials I've linked above. You'll learn more from them, and be less confused by what is 3rd party code supplied by the book. Substitute the "rendering" techniques you would learn from a 3d book with a good 3d math book and realtime rendering (links below)]Essential Mathematics for Game Programmers or 3D Math Primer for Graphics and Game Development: 3D programming involves a lot of math, these books cover topics that OpenGL/DirectX books tend to rush over.
Realtime Rendering: A graphics library independent explanation of a number of modern graphical techniques, very useful with teaching you inventive ways to use your newly found 3d graphical talents!
I would recommend reading Design Patterns: Elements of Reusable Object-Oriented Software. That book will give you the majority of design knowledge you would gain at this point in your career from college.
Design Patterns by the gang of four. It is the essence of designing software architecture. It describes very common designs that have been tested time and time again, however it is broad and you have to specify your requirements but it is an amazing starting point.
(ps it actually is similar to design problems in civil architecture identified by Christopher Alexander. A Pattern Language (1977) & A Timeless Way of Building(1979).)
It really opens doors to how you should approach and choose the correct design. It's not language specific. The book however does have C++ examples
The resource seems very extensive such that it should suffice you plenty to be a good software engineer. I hope you don't get exhausted from it. I understand that some people can "hack" the technical interview process by memorizing a plethora of computer science and software engineering knowledge, but I hope you pay great attention to the important theoretical topics.
If you want a list of books to read over the summer to build a strong computer science and software engineering foundation, then I recommend to read the following:
The general theme of this list of books is to teach a hierarchy of abstract solutions, techniques, patterns, heuristics, and advice which can be applied to all fields in software engineering to solve a wide variety of problems. I believe a great software engineer should never be blocked by the availability of tools. Tools come and go, so I hope software engineers have strong problem solving skills, trained in computer science theory, to be the person who can create the next big tools to solve their problems. Nonetheless, a software engineer should not reinvent the wheel by recreating solutions to well-solved problems, but I think a great software engineer can be the person to invent the wheel when problems are not well-solved by the industry.
P.S. It's also a lot of fun being able to create the tools everyone uses; I had a lot of fun by implementing Promises and Futures for a programming language or writing my own implementation of Cassandra, a distributed database.
Hi PizzaPartify,
I believe that different companies/teams will place emphasis on different skills. When I was helping to hire software engineers for EA's motion capture studio, I liked to see candidates who showed a strong aptitude for engineering code to be maintainable. For me, this meant a familiarity with design patterns and software development processes (like Test Driven Development or Extreme Programming). In my department, much of our code was in C++ and Python. However, other departments would use languages like Java, C# or ActionScript - depending on the project.
It would be helpful to know what role you are applying to.
To answer your specific questions:
Regardless of the language you're working in, I would also recommend Design Patterns by the gang of four (http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612).
A game-specific recommendation is Game Engine Architecture by Jason Gregory (http://www.amazon.ca/Game-Engine-Architecture-Jason-Gregory/dp/1568814135). It doesn't matter if you intend to write an engine or not, it is immensely helpful to understand how they work.
I own all of the Game Programming Gems books but use them more as a reference library. The books above will be more helpful right now.
I hope that helps.
Three CS fundamental books in the order I'd suggest someone read them if they don't have a background in CS.
Elements of Reusable Object-Oriented Software - "Gang of Four". My preferred way to consume this book is to read it lightly, understand the basics of the patterns, and then come back to them individually when you encounter them in the wild or think you want to employ one of them.
Then there are these books that aren't really "CS books", but are geared more twoards practitioners.
Algorithms, Design Patterns, VCS, being familiar with typical CS interviews questions and something that will be really needed
Some Books:
For Algorithms:
http://www.amazon.co.uk/Algorithms-Sanjoy-Dasgupta-ebook/dp/B006Z0QR3I/
http://www.amazon.co.uk/Algorithm-Design-Edition-published-Springer/dp/B00E28CR4I/
http://www.amazon.com/Introduction-Algorithms-Thomas-H-Cormen/dp/0262033844/
Design Patterns:
http://www.amazon.com/Design-Patterns-Explained-Perspective-Object-Oriented/dp/0321247140/
http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124/
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/
http://www.amazon.com/Design-Patterns-Dummies-Steve-Holzner/dp/0471798541/
Interviews:
http://www.amazon.com/Cracking-Coding-Interview-Programming-Questions/dp/098478280X
http://www.amazon.com/Programming-Interviews-Exposed-Secrets-Landing/dp/1118261364/
From what I understand they're a way to structure your code to solve specific problems. An example would be a combination of the Factory pattern and the Component pattern as a way to use data driven design to create "things" in your world (I have enemy Bob, Bob.txt/Bob.xml/Bob.whatever has all the information to create Bob. The "factory reads in this info, and then handles creating the entity and components.)
If you'd like to learn more there's the gang of 4 book Design Patterns: Elements of Reusable Object-Oriented Software, and for a focus on design patterns in games I liked gameprogrammingpatterns.com
The amount of planning you have to do scales with the complexity of the project.
Professors drill the importance of planning, documentation and unit testing into students because it is extremely important and once you start your career if you're a poor planner it's going to come back to haunt you.
However, when you're working on a simple project that's not intended for public release you don't have to go overboard with docs unless you just want to practice.
My own process usually starts with me jotting down an idea; I find that writing it out helps me to get a better grasp on the overall feasibility.
Once I'm satisfied that I actually have something I can implement I'll diagram the flow of the application, and maybe do some wire-frames.
I usually find that this is enough of a launching pad for a simple personal project.
Professional projects are a different ballgame, because as I said, the amount of planning you have to do scales with the complexity and size of the project. It's in the professional environment that all of the things your professors are teaching you will become really important.
So, to answer what I think was your question,
>So how does one end up with 20 classes connected with each other perfectly and a build file that set everything up working flawlessly with unit test methods that check every aspect of the application?
This comes about more in the implementation phase than the planning phase. I've heard it said that in war "no plan survives contact with the enemy" and you'll find this to be true in software development as well. Even when you plan really well you'll sometimes have to go back to the drawing board and come up with a new plan, but that's just part of the process.
Some books that I recommend on the topic are Hackers and Painters - Paul Grahm and I think every software dev should have a copy of Design Patterns
The former is a collection of essays that might give you some useful perspective on the process of writing software.
The latter is more of a reference book, but it's helpful to become familiar with the patterns covered in the book so that you don't find yourself re-inventing the wheel every time you begin a new project.
As for the other part of your question (apologies for addressing them out of order)
>My new "bottleneck" writing code is the structure. I end up having huge classes with way to many public methods. I might as well just write a script with everything in one file. Almost anyway.. I try to write OO, but I often get lazy and just end up with not very elegant systems I would say.
Don't be lazy, because as you're already seeing, it comes back to bite you in the ass.
As you're writing your code you have to be mindful of the complexity of the project as it grows around you, and you have to periodically take a step back and look at what you've created, and re-organize it. This kind of goes back to what I was saying earlier about no plan surviving enemy contact.
So when you find yourself creating a new class that you hadn't thought about, be mindful of where you put it.
Should you create a new file (yes, of course you should), new folder?
Do you have a bunch of similar classes doing the same thing? Should they inherit from one another?
Be especially mindful of copy and pasting from one are of your code to another, generally speaking if you're doing this you should probably be writing a function, or using inheritance.
It's up to you as the developer to make sure your project is organized, and now-a-days it's really easy to learn how to best organize code by looking through other peoples projects on github, so there's really no excuse for it.
Hope that helps, good luck.
Beginner and Novice are the same thing. It sounds like you're trying to transition of Beginner to Intermediate.
You really should stop trying to write your own framework for the moment, and start using a mature framework. Good frameworks aren't trivial to write, and generally require an expert level of knowledge to write well.
The thing with a framework is that it helps remove you from a lot of boilerplate code - that is, common code everyone would normally need for any give web project. The easiest way for you to bridge the gap is to begin using and understanding code that is better than yours. Don't reinvent the wheel until you understand how to make a better wheel.
Design patterns are everywhere in good code. The trick is to recognize when a design pattern is being used, and to understand why it's being used. In order to help with this, it's commonly recommended to read Design Patterns: Elements of Reusable Object-Oriented Software. This is a book every programmer should own regardless of the language they use.
Knowing a giant list of programming languages is really overrated. Instead, focus on learning new programming concepts.
Sometimes that can mean learning a new language, but not always. Some examples:
And regarding your concern of it being harder to learn new languages later, you'll only really have that problem when learning a vastly different language (such as Scheme when compared to your C#). Once you know one language in the same "family", a lot of knowledge carries over.
http://pragprog.com/the-pragmatic-programmer/
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Hitchhikers-Guide-Galaxy-Douglas-Adams/dp/0345391802
Indeed I can. =D
C and C++ are pretty different nowadays depending on your standard. "Game engine" is a pretty generic descriptor, because you can build game engines in a lot of different ways depending on your needs for the genre and how all-encompassing your engine needs to be, so I'm going to ask you a few questions about specifics in regards to your experience which might help to flesh out where you can start your search.
Hope this helps.
Here's a rough outline, from high level to low(ish):
Extra Credit
That will get you started but there's tons more. The best thing you can do is write code and read code and be patient.
One of the things we can do to make our lives harder in software engineering is muddle terminology. It adds needless friction to our job if when you say "flernb" you're referring to a widget but when I use say it, I'm talking about a whozit.
In low level code, we're pretty good about sticking to the first term that was coined for something. If you have a series of objects, each with a reference to the next, you'll probably call it a "linked list", just like I would.
But when it comes to higher-level architecture and design, names get a lot messier. Fortunately, some dudes wrote a book that tries to be the beginning of a taxonomy for architecture. Ultimately, the names they pick are arbitrary, but if we all agree to stick to them, then they become concretely useful.
What the author describes here is not a proxy. A proxy is a local object that represents a distant one, usually on another machine or process. It's not a very common part outside of distributed systems.
The author created an adapter.
These are all good points.
With respect to Design Patterns, I feel that the holy grail is Design Patterns - Elements of Reusable Object-Oriented Software by Gamma et al.
You probably already have, but if not, definitely read Design Patterns, which is old but a classic. I'd also highly recommend the Pragmatic Programmer.
EDIT: I just want to say, that I also fully support alienangel2's answer. I wanted to recommend a couple good books to get you on "the path", but ultimately, the best thing by far is to find a job that grows you. For some people, the best way to do that is to work at a super small startup, where everything you're building is from scratch. For others (like me), the best way is to work at a company with tons of really smart people who have already built great software, and learning from them and the choices they've made (and why). And if you still feel like you're regressing since school, maybe that's the answer: go back to school (i.e. get a Master's or PhD)!
From wikipedia, and I highly recommend this book as reference material.
Books
Stuff to watch
Blogs
Other resources
Learn by experience and by reading is probably the way to go. The gang of four's design patterns is still the de-facto standard:
http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
I really love this book for Java design patterns though, fun to read and really informative:
http://www.amazon.ca/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&ie=UTF8&qid=1333263240&sr=1-1
Then it's a matter of knowing when and where to apply them, which is a harder problem and just an experience thing I'd say.
They seem a like reasonable starting point I think. Repetition is the mother of mastery, the more books the better (in addition to applying what is learned).
Since Mosh is calling out learning fundamentals as important to becoming a good C# developers, I would personally also recommend some general (non C# specific books) too for who are starting out in software development:
There's a ton more, but those are a few that stood out to me. Essentially the more the merrier in my opinion - books, courses, videos, tutorials, and so on. The books I'm recommending here focus on adopting the developer mindset and being successful at it. That's part of the puzzle.
The other part is understanding the technical details including the programming language and frameworks you intend to use.
And finally, for learning about C#, I do highly recommend Mosh's videos/courses (some are free on YouTube, others available on Udemy). He's got a unique ability to explain things clearly and simply in a way that beginners can pick up quickly.
What I'd do is check out his free content first, and if you agree his style is ideal for learning, an investment in one of his courses is well worth it since he'll cover a lot more breadth and depth on each of the topics and they're organized into a super consumable package rather than scouring the internet for various topics.
https://www.amazon.com/dp/0201633612/?tag=stackoverflow17-20
https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
And you could check stack overflow for question on general programming books. I would always go for a general concept
functional programming
overhow to functional programming in haskell
.But I'll be perfectly honest, I'm a victim of the curse of knowledge so I honestly don't know how one should start. What I do remember is that I had huge problems with syntax (how do I tell language X to do a
for (Employee e in employeeList)
, how do you write a switch and stuff, why would I ever need a ternary operator, and like that.But once you master the basics of how to write x, y and z in your preferred language, you absolutely need to understand design patterns, you absolutely need to understand how code is supposed to be written, you absolutely need to understand data structures, you absolutely need to understand inheritance and polymorphism, you absolutely need to understand lambdas and functional programming.
Then you can get to the more "neat" stuff like the benefits of having immutables, and "job specific stuff" like how to solve race conditions in threading; sockets and web communication, etc.
Two things: The coursework from my CS degree, and reading books about software engineering.
I've spoken in other places about the former, and for the latter, I recommend The Pragmatic Programmer, Code Complete, and Design Patterns: Elements of Reusable Object-Oriented Software
The book, Head First Design Patterns, is actually pretty good.
You could also read the book that started it all, Design Patterns: Elements of Reusable Object-Oriented Software. Although good, it is a dull read - I had to force myself to get through it.
Martin Fowler is also really good, in particular, I thoroughly enjoyed his book Patterns of Enterprise Architecture.
If you want more of an MS/.NET slant of things, you should also check out Dino Esposito. I really enjoyed his book Microsoft .NET: Architecting Applications for the Enterprise.
My recommendation would be to start with the Head First book first, as this will give you a good overview of the major design patterns.
There are several good books on designing good software:
Code Complete
Design Patterns
Refactoring
While data structures and algorithms are important, don't forget design patterns!
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_other_awd_FW0ywbGSR9PB5
Design Patterns (aka Gang of Four)
https://www.amazon.co.uk/Design-patterns-elements-reusable-object-oriented/dp/0201633612
Small employment gaps are no big deal. Over six months people may ask, but it's all in how you answer. I'm not sure why you feel like you're unmarketable having worked in the industry for two years, but do know a lot of the postings - especially junior postings - are inflated. I've seen one that asked for three years of experience with Visual Studio 2019. If you're halfway there, shoot your shot.
As a junior dev, the expectations are low. All I'd expect you to know is how to get code up and running that I don't have to tear down for the good of the company. Be able to read your language and solve simple problems. The biggest thing I look for in a junior dev is if I can give them some piece of of the software to write while I'm not looking and feel that you're mostly there when I come back to check. Apply for appropriate positions and don't fudge your experience. Enthusiasm and eagerness to learn go a long way. Don't be a know-it-all from your position.
Decide what kind of role you'd prefer, and start the process of brushing up on that. Use the job postings that represent the jobs you want as direction on what you need to learn. If the role you really want is too far, get a job doing what you know to pay for your education in the role you want.
As a front-end developer, you're going to want to learn a Javascript toolchain and one modern framework to start. Npm and Node.js are the backbone of what you do. If you want to switch, learn what juniors do in that paradigm. Do know that the Javascript world is fast-paced and fad-based, so if you miss a wave, wait two years and the next one will be coming around for you to hop on.
Personal projects are a good idea, just make them meaningful by using the proper setup (not just some bullshit hack job) or address an interesting problem. You're going to want to get it up on a personal repository that you can put a link to right on your resume and job site (Indeed, Dice, Glassdoor, Linkedin) posting. Be able to speak to every decision you made, even if it was a bad one. Your personal project doesn't have to be spotless or even completely done, it just has to be yours, it should be able to execute, and you should show some decent decision making. A mod for a game, a contribution to open source, a personal thing that has some use-case or whatever.
Get experience with related technologies. Start to learn one step before and beyond the one you're a specialist in. For example, you're a junior front-end dev. Learn a little about backend work, and learn about deployments. Learn about the experience of your fellow team members as they try to integrate your work with Git, build with Jenkins or AWS Code Build, and containerize with Docker. Think about the pain points you face in architecture, code, building, and deploying; think about how you'd solve them or if you can't, keep an eye on solutions as you go. Know the differences between elements of your chosen sphere.
Higher level concepts like SOLID principles,Design Patterns, and Refactoring Patterns are more goals than expectations, but you should take a look at them now and at least be able to speak to at least one of them somewhat. With limited time, prefer Design Patterns. You don't want to walk into an interview where someone asks you about how you use design patterns and you've never heard of them. Even if they'll accept that, you still won't feel good about it.
Look up some materials on coding challenges, as some companies give coding quizzes. I just had an interview with a guy that touted 10+ years of experience but couldn't read from a file given an hour.
If you feel like you're going to be let go due to performance, get ahead of that and ask your supervisor how you're doing or what you need to do to grow. If you feel like you're going to be let go due to a restructuring you can't affect, you have two options: get to know other teams so you can maybe hop on their project later, or just save your money and get to work on some of the stuff above each weekend until the axe falls. You're a junior dev. You're not expected to be perfect, but you should come in a teachable state - some foundation with programming, a willingness to learn, a willingness to figure things out, and the ability to take direction.
Introduction to Algorithms by CLRS. Used in almost every algorithms class I've heard of, and a great reference book. It's about 1300 pages, so don't try to read straight through it.
C Programming Language by K&R. This is a C programmer's Bible.
Design Patterns by the Gang of Four
This is a little more of a topic book, but The Art of UNIX Programming by Raymond.
These are all either pretty common, or almost essential. You'll probably see these in your curriculum anyway, and you should. These are a good cornerstone.
Perhaps offtopic but... Some books you should read regardless of CompSci branch
MVC is just a paradigm. Implementations differ from language to language, and some languages have better support than others, but yeah, just a paradigm.
Look into Design Patterns by the (in)famous "Gang of Four" for more information about this.
I will say this -- most experience I have with C# backends leads to great usage of databinding between model and view regardless of application platform (WPF, Windows Forms, even some ASP.NET). And I'm pretty impressed with the support of other design structures that C# and Visual Studio offer with the help of NuGet (looking at you, Angular).
I'll start off with some titles that might not be so apparent:
Unexpected Fundamentals
These 2 books provide much needed information about making reusable patterns and objects. These are life saving things! They are not language dependent. You need to know how to do these patterns, and it shouldn't be too hard to figure out how to implement them in your chosen language.
 
Good General book
 
This book is great if you're going to make a browser based game
 
General Knowledge books
 
Provide a working moveable 3D model with C++ and DirectX, Very cool.
 
More general game base building
 
Working product results books, little if any modification needed
Releasing in a couple months (hopefully) 2 Very good books using C++ to develop by.
 
Not presented in the best manner but still noteworthy:
 
I used to love XNA...but now it's not feasible for commercial development. If you're a beginner to game design...starting out with XNA might actually be useful. It's easy to pickup and put out a working product. XNA is C#
 
 
Working product books, modification needed to make run on current systems
Provides a working FPS game in C++ on DirectX 9. Good for some starting out knowledge for an FPS
 
Good for 3D Terrain rendering in DX9...however much of this is outdated...some concepts still apply, and it's not the worst idea to see a working example.
 
TLDR: Click links starting at top, buy, read, profit
It really depends on your use case. A good starting point (I'm assuming architecture in software) would be to read Design Patterns by Group of Four. It uses C++ for it's examples and is quite a dense read, but is worth the read.
Not specifically game-related, but the great classic Design Patterns: Elements of Reusable Object-Oriented Software is really well written, and it's patterns are as applicable to game design as they are for anything else.
You do say you're an experienced programmer though, so you may already know many of the basic general design patterns in there (or you may have read the book even).
In addition to Code Complete 2, which, while very dense, is a compendium of wonderful coding knowledge... I recommend Clean Code by Robert C. Martin.
One of the best books on concurrency that I've ever read is definitely Java Concurrency In Practice it's (obviously) written with Java in mind, but most of the concepts map rather easily to constructs in other languages as well.
The standard for design patterns is still probably Design Patterns (colloquially "Gang of Four")... but I've heard good things about Head First Design Patterns as well, despite the really stupid cover.
> Computer science is about building things like engineering but without the luxury of a toolbox and components taken from the physical world. No one has worked out reliable and effective procedures for building large pieces of software as the engineers have done for physical project.
At first, I started to take issue with this statement because of software patterns. But I he means more than this. The author's points were thus:
IMHO, the author's points are a human problem, not an engineering problem. In point 1, a project manager didn't set expectations for a client. In point 2, developers did not use tools that exist. Buffer-overrun protection DOES exist (his example), and other technologies help modularize software properly. Hell, cohesion and coupling are among the core software design principles. In point 3, again, a project manager did not properly set expectations for the client. PM technologies like agile methods have been developed to fight this. Further, because software is much newer to the human knowledge collective, it's less well understood. When it has been around for as long as architecture and machines, clients will have better expectations of the process.
In all, it sounds like his experience with software has not been true engineering rather than modern software development techniques.
A good place to start might be learning some of the common design patterns, these are common solutions that have been found to work over and over. The standard book for learning them is this one: http://www.amazon.com/Design-patterns-elements-reusable-object-oriented/dp/0201633612
It's not a PHP book but the patterns it covers can be used in any language, there's also loads of stuff on Wikipedia around them: http://en.wikipedia.org/wiki/Category:Software_design_patterns
Learning how to approach a programming problem is at the heart of being a good programmer and it's something you'll always be able to improve on (I'm still learning after 15 years of programming) so I would recommend a combination of trying to read as many programming books as you can, asking for help on StackOverflow when you need it, looking through well written open source code to see how those guys approach problems and above all else, practice, practice, practice.
Design Patterns: Elements of Reusable Object-Oriented Software doesn't use JS for it's examples, but is highly regarded in learning design patterns.
Also, Mastering JavaScript Design Patterns is pretty good, and if I recall correctly, is modeled after the first book I mentioned. Heads up, there is a more up to date 2nd edition of this book available (linked version is 1st edition)
My blog about software architecture: http://www.tutisani.com/software-architecture/ (may not be for very beginners but I hope that it's able to communicate important topics).
I'd also suggest reading the classic book about design patterns (a.k.a. Gang of Four): https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_3?crid=1XRJO0L09LHLY&keywords=design+patterns+elements+of+reusable+object+oriented+software&qid=1557502967&s=gateway&sprefix=design+patterns%2Caps%2C162&sr=8-3
There are several good thought leaders in this direction, specifically Martin Fowler (https://martinfowler.com/) and Eric Evans (he does not write much online, but his book is great - all about modeling properly): https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215
​
I'm big on modeling, objects, etc. so reply back if any questions.
Design Patterns by Erich Gamma , Richard Helm , Ralph Johnson , John Vlissides
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_3?ie=UTF8&qid=1549541116&sr=8-3&keywords=design+patterns
Concurrency in Practice by Brian Goetz
https://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/ref=sr_1_1?ie=UTF8&qid=1549541190&sr=8-1&keywords=concurrency+in+practice
Clean Code by Robert C Martin
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=pd_sim_14_4?_encoding=UTF8&pd_rd_i=0132350882&pd_rd_r=cf3a76e3-2ad0-11e9-91c7-79eddbe046cc&pd_rd_w=RVwGU&pd_rd_wg=ZJ2Iq&pf_rd_p=90485860-83e9-4fd9-b838-b28a9b7fda30&pf_rd_r=4P48EDFQ0VNRGZYAE96S&psc=1&refRID=4P48EDFQ0VNRGZYAE96S
Read lots of code and read books to get multiple viewpoints. This is a deep topic which will require more than superficial online reading.
Check this out.
Books I have found useful:
Pragmatic Programmer, Clean Code, and Head First Design Patterns come to mind right away. They're 3 of my favorites.
There's also Design Patterns by the Gang of Four. That's a lot more dense IMO than Head First, but it's fantastic material.
Since you're looking to jump ship and start interviewing, take a look at Cracking the Coding Interview. That will prepare you for any questions you run into during the process.
It's probably also worth brushing up on Algorithms and Data structures.
Seconding The Pragmatic Programmer and Cracking the Coding Interview. I'd also recommend:
If you let us know which languages you primarily write, I can probably recommend some good language-specific titles, too.
For language specific stuff like c++ I'd suggest:
https://www.toptal.com/c-plus-plus/interview-questions as a pretty good quick review. Going through c++ primer (or whatever book you learned C++ from) and just touching on all the topics that you don't remember can help a lot.
What helped me with design patterns is head first design patterns. Even though that book seems very 'intro' it has helped me pass all the design pattern question I've ever gotten. I think just visitor, singleton and MVC are the most popular interview design patterns. The more canonical 'gang of four' book would be: this.
For just practice tech interview problems that you'll see on silicon valley, big4 tech interviews, the most popular site is probably leetcode (hackerrank, or top coder or even codewars are pretty good sources too). The most popular book (as mentioned many times) is Cracking the coding interview.
Just grinding out problems on leetcode, you'll probably learn enough to pass most tech interviews after about 100-200 questions (if you've never done this before, less if you have).
Before/during your leetcode practice I've written a series of tech interview tips to help you check on your fundamentals (you can check it out at fizzbuzzed.com). I try to go over the questions I see people failing most often. I'm also trying to help readers so would love to help you if you run into problems.
I also think you should ask the recruiter the style of interview you'll be having. If you are on the whiteboard then you should practice on it before hand (whiteboard interview tips here.
There are books out there, many of which are unfortunately not language agnostic, that deal with this. What you want to know is the basics of object oriented design and, most importantly, design patterns, which are general answers for recurring object-oriented design challenges. You may have to dabble into languages other than the one(s) you currently use in order to follow along.
The last one is the book on design patterns.
I have included some links for more information about myself in the original post.
To have a better idea of the type of person I am these are the books within my arms reach right now:
Design Patterns: Elements of Reusable Object-Oriented Software
[Refactoring: Improving the Design of Existing Code](
http://www.amazon.ca/gp/product/0201485672)
The Mythical Man-Month
Along with some other ~50 similar books I've read.
Everybody's learning style is different. Here are some books I believe to be essential for any novice or pro.
Programming For Dummies. It has a stupid title, but it is well reviewed for good reasons. I read through this beast in three weeks. There is no coding involved, as it is mostly theory, but it covers most of the bases of computer science and programming logic. Looking back, much of it confused me at first read, but the big ideas are all presented here. Reading this during the summer before first semester was a huge boost for me. All of the major computer languages are discussed in the book.
Cracking the Coding Interview. A book meant for veterans trying to get into highly demanding top tech companies, the book is a great introduction to programming paradigms. There are numerous examples of problems in each chapter with answers at the back of the book. The whole thing is in Java, with a short chapter on C++.
Design Patterns. As you learn more about object oriented programming, the concept of design is introduced. This book is the holy grail of software architecture and recommended by many. I would hold off acquiring it until you are certain that CS is where you want to be, it is quite technical. This book follows C++, although a Java version of the patterns exists on Github.com
A non-technical book just for fun:
The Innovators is essentially the story of computer science and how it got to present day. It follows the characters, human beings, that were involved each step of the way right up until modern day. Your professors will be impressed that you know who Alan Turing, Grace Hopper, and Charles Babbage were. If only I had been at THE MOTHER OF ALL DEMOS! The actual stories of Microsoft, Apple, The internet, the PC, video games, the space program, etc. On Quiz Up, a trivia app, every other question in the CS category involves names from this book. Read it just to be a real geek that knows where this stuff came from, and the drama/tension that led to innovation. The book is actually really funny at times.
I would add design patterns to that list...they are extremely helpful and it essentially what modern frameworks try to put in place.
It's why MVC/etc exists, and if you are fluent in many design patterns then you can mix/match/modify the appropriate one to your current problem set. Also, things like that transfer to non-backend development if you ever decide to go that route.
See books such as Design Patterns: Elements of Reusable Object-Oriented Software - written by the 'gang of four'...and other related and more modern derivatives of this.
I'm freshening up on Python for work, and these are my materials:
Mastering Python Design Patterns https://www.amazon.com/dp/1783989327/ref=cm_sw_r_cp_awd_kiCKwbSP5AQ1M
Learning Python Design Patterns https://www.amazon.com/dp/1783283378/ref=cm_sw_r_cp_awd_BiCKwbGT2FA1Z
Fluent Python https://www.amazon.com/dp/1491946008/ref=cm_sw_r_cp_awd_WiCKwbQ2MK9N
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_awd_fjCKwb5JQA3KG
I recommend them to OP.
I've posted this before but I'll repost it here:
Now in terms of the question that you ask in the title - this is what I recommend:
Job Interview Prep
Junior Software Engineer Reading List
Read This First
Fundementals
Understanding Professional Software Environments
Mentality
History
Mid Level Software Engineer Reading List
Read This First
Fundementals
Software Design
Software Engineering Skill Sets
Databases
User Experience
Mentality
History
Specialist Skills
In spite of the fact that many of these won't apply to your specific job I still recommend reading them for the insight, they'll give you into programming language and technology design.
Per testare le acque velocemente puoi usare https://rubymonk.com/ (introduce Ruby in modo basico). Anche Coursera, Khan, Udacity e simili hanno corsi introduttivi sulla programmazione.
Mentre se vuoi imparare a programmare, il percorso deve toccare almeno tutte queste tappe, in ordine:
Organization-Design-Fourth-Edition/dp/0123744938)
Da qui puoi partire e specializzarti in quello che ti interessa
The "gang of four" book titled Design Patterns is an excellent reference for object-oriented architectures.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Note - this really is more like a reference book than a tutorial or gentle introduction. It's not something you read cover-to-cover.
This is a really big question, and not really specific to javascript. Architecting large applications, in my opinion, is kind of an art form. You can learn strategies by reading, but you're not going to get good at it without years of experience. Ideally you learn this stuff while working alongside strong senior developers who know what they're doing.
Read Design Patterns, if you haven't. I'd also recommend Javascript Alongé, but I'm a functional programming crazy.
Build something in a way that feels right, then evaluate what worked and what didn't. Which parts sucked to modify when requirements or assumptions changed? Which parts were hard to understand a month later?
In general, I have a few guidelines:
Design Patterns (sometimes called the "gang of four" book) is the best book I know of about design patterns- and I haven't heard of it being used in college courses (I could be wrong). This will give you a sense of the patterns that are out there, but knowing which pattern to use when is still mostly experience and even team-based preference/convention.
CS programs give you a broad overview of computer science theory, which is helpful but is not in any way sufficient to prepare you for programming practices. What you're going through is totally normal.
Debugging someone else's code is a skill that is also not taught in schools. I actually did a talk on debugging skills a few years ago; the slides don't make much sense but we made a PDF of our main points. I'll see if I can find video when I'm not on my phone.
I'm happy to talk more about this stuff with you or anyone else reading this; pm me or email carol dot nichols gmail.
You need to understand there are a couple of ways to do Java web development.
Definitely learn Hibernate. You can start with the JPA material in the Java EE tutorial.
As for design patterns, Design Patterns: Elements of Reusable Object-Oriented Software is a classic. I also like Patterns of Enterprise Application Architecture for more of an enterprise system pattern view of things. Probably avoid most J2EE pattern books. Most of the Java EE patterns come about because of deficiencies of the J2EE/JavaEE platform. As each new version of Java EE comes out you see that the patterns that have arisen become part for the platform. For example you don't create a lot of database DAOs because JPA/Hibernate handles your database integration layer. You also don't write a lot of service locators now because of CDI. So books like CoreJ2EE Patterns can interesting but if you are learning a modern Java web stack you'll be amazed at how archaic things used to be if you look at old J2EE pattern books.
p.s. Don't buy anything that says J2EE, it'll be seven years out of date.
I didn't look through your code.
Just some general advice: Don't force design patterns into your app. Design patterns are solutions to common problems. You should just be familiar with them to recognize when you're trying to solve a common problem.
You should read this:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1427141980&sr=8-1&keywords=design+patterns
The "Gang of Four" design patterns book http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&s=books&qid=1251223171&sr=8-1 is the one that started it all. There are code samples in C++.
I've also heard good things about the "Head First Design Patterns" book.
As far as your courses go, the best book I can recommend is Algorithms in a Nutshell. It is a small book which quickly introduces you to most of the core algorithms you will use throughout University. It also covers measuring efficiency through "big O notation" - a very important concept in CS.
If your University's SE program is anything like the one I am familiar with, you will also be focusing on software engineering principles. The most important SE books I ever read are:
These three books have strongly influenced me as a developer
Design Patterns (Gamma, Helm, Johnson, Vlissides)[aka the Gang of Four] is THE Design Patterns book, but it's a little dry and I don't think it talks about MVC that much. I've gotten about 1/3 of the way through it twice, I just keep getting distracted and forget about it.
Head First Design Patterns has gotten a lot of good reviews and I've head good things about the Head First series of books, but I haven't read any of them myself.
I'm not sure about any online tutorials, but I'm sure they exist.
I taught myself a little about Design Patterns and MVC, but I'm sure I understand them just enough to be dangerous. I'm going to be taking a class this Fall that should talk about Design Patterns more.
What books can help you expand your knowledge of design patterns?
The second one (GoF book) is the defacto standard, but unfortunately, it's also a cure for insomnia. The first one is much more entertaining.
Only ever fully read a single programming book, and that was because the material was best learned through a book. It was about non language specific design patterns. It was a key that unlocked so much knowledge for me.
The book is Design Patterns: Elements of Reusable Object Oriented Software. It's old but it does not matter. Object Oriented design patterns don't change much because they are tried and true, and you will see them in every OO language. While JS is not technically OO (though ES6 introduces some strong OOP features), it still uses many of the same patterns!
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Cara, reinventar a roda não é ruim! Resolver problemas clássicos é uma ótima maneira de aprender e praticar é a melhor maneira de melhorar em algo. Eu sou o tipo de cara que gosta de aprender as coisas na prática então sou suspeito de falar mas vai lá e desenvolve. Essa minha aposta com meus amigos é justamente para nos forçar a isso, desenvolve qualquer coisa mesmo que seja algo completamente inútil, que é melhor do que ficar parado. Umas semanas atrás, nessa aposta um dos meus amigos desenvolveu um script que calculava se era ecologicamente correto urinar no chuveiro ou na privada, utilidade real do projeto é nula, mas fazendo isso ele já começou a aprender uma nova linguagem e investiu tempo em se tornar um programador melhor. Realmente meu conselho é faça, desenvolva! Uma dica é pegue pequenas coisas do seu dia-a-dia e resolva elas com programação, por exemplo, uma vez eu fiz um script que me perguntava quais ingredientes eu queria em um lanche, ai ele varria o site do iFood e me falava qual era a opção mais barata que eu tinha. Não tinha necessidade alguma de fazer isso, era muito mais rápido fazer uma busca manual, mas na época isso me ensinou a usar a BeautifulSoup e foi super divertido de fazer.
Although I agree with the others and good coding pillars are important. C# can be incredibly easy to learn and as such it's great for beginners to start with. Focus small and build up from there. I would write simple console apps understanding the core concepts before you move into actual gamedev coding. Without a strong fundamental grasp of how C# works you'll end up rewriting code in your game later on as you learn new things. You might spend a good chunk of time doing something a very tedious way only to discover that there is a much easier way later on. Also as others have said code agnostic coding pillars are very important. Some good books:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://gameprogrammingpatterns.com/contents.html
Understanding how to structure your code is very important.
I was underwhelmed by code complete, although I had really high expectations after jeff atwood gushed about it so hard.
Design patterns I don't hear brought up very often but I found it extremely useful. Even if you don't use or even like some of the patterns you are likely to encounter them in your programming career at some point and being able to recognise them is invaluable.
By biology I don't mean what they teach you in college or med-school, I mean understanding the basic processes (physiology-esque) that underlie living things, and understanding how those systems interact and build into more complex systems. Knowing the names of organs or parts of a cat is completely worthless, understanding the process of gene-activation, and how that enables living organisms to better adapt to their environments, especially, for instance, for stress factors activating responses due to new stimuli, can be very valuable, especially as a function of applied neurology.
Also, what we call biology and medicine today will be so pathetically obsolete in 10 years as to be comical, similar to how most mechanics can rebuild a carburetor, but not design and build a hybrid drivetrain, complete with controller software.
Economics and politics are controversial, but it is a question of seeing the underlying forces that is important, similar to not understanding how gravity works, but still knowing that dropping a lead ball will accelerate downwards at 9.78m/s^2. This is a field that can wait till later though, and probably should.
For systems analysis, I'm sorry but I can't recommend anything. I tended to learn it by experience more than anything.
I think I understand what you are looking for better now though, and think you might be headed in the right direction as it is.
For CS I highly recommend the dragon book, and design patterns, and if you need ASM The worst designed website ever.
For the other fields I tend to wiki subjects then google for papers, so I can't help you there. :(
Best of luck in your travels however! :)
edit: For physics, if your math is bad get both of his books. They break it down well. If your math is better try one of wittens books, but they are kinda tough, guy is a fucking genius.
also, Feynman QED is great, but his other book is awesome just as a happy intellectual read
also try to avoid either kaku and hawking for anything more complicated than primers.
edit no. 9: mit's ocw is win itself.
edit no. 10: Differential equations (prolly take a class depending on your math, they are core to almost all these fields)
The Pragmatic Programmer and Design Patterns.
The Pragmatic Programmer is a really enjoyable read about practical decision making and coding practices. Design Patterns is more for reference, both great books. You can google the design patterns though, but I like to have a copy of the book anyway.
So I don't think you should get too hung up on "enterprise architecture" at the moment, partially because you're still very early in your career, but also because enterprise architecture means a lot of things to a lot of different people. At this stage in your career, I really think you should focus mainly on SOLID code, core Object Oriented design concepts, and then understanding patterns. Good architectural strategies are built around all of those concepts, but they're also much much more than that.
For SOLID code, one of my favorite references is actually Dependency Injection in .Net by Mark Seemann. Although he does spend a good amount of time on DI, the recommendations that Mark makes for how to properly structure your code in order to take advantage of DI are very useful in understanding SOLID oriented design principles in general. The examples and code really work through the concepts well, so you get a great explanation followed by some well thought out code.
Clean Code by Uncle Bob is a great reference on how to structure well thought out code that touches on some architectural principles, but doesn't have that as the main focus of the book. Many of the topics in the book you'll find need to be addressed throughout a codebase.
As far as design patterns (which are different then architectural patterns), I don't think you can go wrong with the original Gang of 4 book , although I personally have a C# specific version, C# Design Pattern Essentials. I don't want to put too much emphasis on design patterns, because sometimes they get overused and applied too literally, but they are still very useful. I think the key to design patterns is not just knowing what they are, but determining where they might be applicable to your use case, and whether you should make any small adjustments or tweaks to them.
After you really have a rock solid base of working with code, then you can shift your focus on more architectural concerns. For that, it really depends on what problem your looking to solve, but Domain Driven Design (DDD) is a good way about understanding those problems and to structure the solutions in a well thought out, loosely coupled, and evolvable manner. That "central framework" that you referenced in your post is the business logic, and its the key focus of DDD
Algorithms? Something like hackerrank.com because there you are supposed to create more complex algorithms from the "simple" ones you learn from books or perhaps in college or from Wikipedia/googling/free online resources.
Design patterns? That book specifically and anything from Robert C. Martin, but preferrably Clean Architecture.
If you are poor there are probably PDFs/epubs somewhere in the web but consider buying the books when they made you rich.
IMO you should go beyond learning node.
Learn javascript (node is just javascript with core libraries).
Actually don't learn javascript, learn how to code.
Even more, learn how to learn.
I'm not the only one with this opinion: http://blog.codinghorror.com/please-dont-learn-to-code/
Also a side point: learn how to test. Testing (may it be unit, behaviour, …) is really important. It helps you code better, have a stronger code (less bugs, or more easily identifiables), more maintainable, and so on.
If you know the basis of code, and how to learn, not only you'll know node, but you'll potentially know php, ruby, scala, whatever.
I strongly encourage you to read:
Those books are references to a lot of developers and will teach you techniques that you'll be able to apply not only to node, but to the most of languages you'll ever encounter.
Just looking for learning, etc? If it's for interview prep, I'd give different recs.
I highly recommend:
These are both general references, I think there are a lot of syntactic python stuff that are unique and awesome, but algorithm stuff and OOP stuff is kinda language independent.
This is one of those questions that basically yields no useful answers.
Not sure if I answered your question. You can checkout topics on design patterns. there's a good book on Amazon for that I think just called design patterns. Or checkout tutorialpoint.Com ? For software architecture.
Design Patterns Book
Software Architecture Quick Overview
edit: added resources and changed format
Design Patterns: Elements of Reusable Object-Oriented Software - This is the object oriented design pattern bible.
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1495660409&sr=8-1&keywords=Design+Patterns%3A+Elements+of+Reusable+Object-Oriented+Software
You could try the gang of four book on design patterns
Two Java specific books you should read cover to cover (and keep around as an effective reference) are Effective Java and Java Concurrency in Practice, and you should also seriously consider reading Design Patterns. The examples in it aren't written in Java but they hold for all OO languages.
Sadly, for a large part of the industry, Java and C# is the standard.
.Net still has a huge marketshare for developers, but Java is gaining quickly. Get proficient in either of these and some Agile development practices, as well as design patterns.
The Gang of four book is the standard design pattern book. I don't know off the top of my head what the best books to get on Java and C# are, but there are huge threads on StackOverflow that will point you in the right direction.
Good luck, my friend!
> learn these patterns practically?
Maybe for now you might want to just read up on them and keep them in mind for the future. For further reading on design patterns pick up "Design Patterns: Elements of Reusable Object-Oriented Software". When you start building something plan it out before hand, preferably with pen(cil) and paper. Once you have some rough idea, see if you can recognize any place where design patterns would come into play. Sometimes they will be intuitively incorporated into your design process, or they will emerge naturally if you try and think holistically about a problem instead of moving your project along piecemeal.
>My goal eventually would be to land an entry C#/.NET position at some software company.
I would encourage you to learn ASP.NET MVC 5, a web framework like Angular or React, and Entity Framework. You may just want to learn the "Core" versions of ASP.NET and Entity Framework then go back .
I've taken this course on udemy on ASP.NET MVC 5, which I would recommend. The same author has put together another course on ASP.NET Core, AngularJS, and Entity Framework which I want to take soon. It looks like they are sequential given the requirements for each course, so you should take the MVC 5 course before you take the ASP.NET Core course. If you created a Github for a sample website (say a pizza shop where users can register, login, and order) and hosted it on Azure to show prospective employers, that could very well get your foot in the door.
Well I'm 40 and didn't really "get" CS until I was in my early 30s, despite doing it for 10+ years prior. Once you turn the corner or whatever it is, things just make sense. For me what helped was going back to the concepts called "computational thinking", as described here https://www.cs.cmu.edu/~CompThink/
I understood the meanings of words like abstraction, recursion etc but didn't really know them as well as I needed to, and didn't know how to see these same basic ideas everywhere, take advantage etc. Also learning some design patterns such as explained in the gang of four book can be eye opening.
edit - book https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Nope.
I've been a professional programmer for 20 years and I still don't formally know design patterns.
What I mean by "formally" is that I naturally use more basic patterns without even realising it.
However, recently I've moved into software architecture for my company, and am finding that there are more and more reasons to learn and understand patterns, as they help design complex systems.
Definitely focus on programming first. Patterns will come.
Also, a tip - people will always recommend the Gang Of Four book (https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) for design patterns. And it is the gold standard book for Design Patterns. However, in my opinion, it is an incredibly 'dry' read.
Head First Design Patterns (https://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&ie=UTF8&qid=1466670651&sr=1-1&keywords=head+first+design+patterns) is a much better introduction to design patterns for most people.
Sounds like what you've done is real/serious programming, just on a smaller scale.
I wouldn't worry too much about not knowing various frameworks. We use Spring to inject dependencies into our client code, we use Glassfish as our application server, and we use JPA backed by EclipseLink as the glue to our data layer. However, when it comes down to it it's mostly about writing plain old Java objects.
For the rest:
Rather than further enumerate my reading list, I'll point you to the Programming FAQ; an excellent resource for exactly the questions you're asking.
Read the GOF design pattern book. For better or for worse, you can't write intermediate Java if you aren't familiar with the basic patterns of Java code
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
There’s really no meaningful content, it’s all just very superficial IMO. You just keep saying what a patten is, list a few at the end and then you don’t explain them or even give examples. Lastly, no relevance to AngularJS in the article, which is the sub you’re posting in.
As far as AngularJS goes, I would recommend most people start with John Papa’s styleguide.
https://github.com/johnpapa/angular-styleguide/blob/master/a1/README.md
As far as JavaScript design patterns go, I would recommend this book.
https://addyosmani.com/resources/essentialjsdesignpatterns/book/
For learning about design patterns and a larger set of them in general, you can’t beat the Gang of Four
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
What you might want to do is pick up a book on design patterns. I am not aware of an good ones specifically aimed, at python though.
Learning the mechanics of doing OOP in python really isn't that hard. Learning how design your objects is the tricky bit. A book on design patterns basically is just a cookbook of things that work. It is about giving you practical examples of when you would use OOP.
Here are a couple books I have on the subject, and have found useful. Reading about design patterns was basically what let me actually understand the point of OOP.
I know it's temping to take the short cut and look for good examples of how to do it in angular, but I beg you to delay that as long as you can.
Instead, start by reading about design patterns in general. Once you understand the major design patterns, most of them appear regularly or can be replicated in language and framework you learn in the future. If you go into angular with this knowledge, you'll spot bad structure much more easily and know how to fix it. Then it's just a matter of looking at the APIs to see how to achieve those design patterns. You may still end up looking for good examples, but you'll have a much better foundation to work from and you'll probably understand the examples more easily and have some theories to help you do the things that aren't spelled out.
There are many resources for design patterns, including wikipedia. The design pattern bible is this book: http://amzn.com/0201633612
>Oh well, can't work on the past
Everything you do today is tomorrow's past.
You need to do some light learning. I'm linking a few books that are fantastic in accomplishing these goals and I think your english is pretty great, so I don't anticipate so much trouble. I highly recommend doing everything in Java; not because I'm arguing that java is what will help you the most, but because almost every code example from these classics refer to Java.
For design patterns, Gang of Four is a good introduction, but it's a little harder to understand http://amzn.to/1giIrF6
I would recommend finding AND implementing these patterns.
Grab a copy of Code Complete by Steve McConnel and Clean code by Robert Martin. That will help you write nice code that you'd be proud to share with a company.
This is a good place to start: http://www.amazon.com/gp/aw/d/0201633612?pc_redir=1409630539&robot_redir=1
As for android specific, no idea.
Design Patterns by the Gang of Four is probably the most cited book on programming design patterns I've ever seen.
Here it is on Amazon. You can probably get a copy cheaper somewhere else though. https://smile.amazon.co.uk/Design-patterns-elements-reusable-object-oriented/dp/0201633612/ref=mp_s_a_1_1
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Objects are for grouping related data and methods together. It really is as simple as that.
Start off by writing applications where you're just creating and consuming objects, not writing your own classes. Java and .NET both have tons of libraries that contain a wide assortment of objects. You mentioned C#, so write a few .NET apps. Try to start identifying and understanding the way properties and methods are grouped into objects, and how the different objects relate to each other.
Once you're comfortable using objects, then you can start writing your own classes. A lot of universities try to teach this by having you write common data structures. This approach is worth considering, as it's important to be familiar with data structures, but this isn't the only way to learn object-oriented programming (nor the best, in my opinion). Another commenter recommended writing a video game, which sounds like it's worth a try. Ultimately, the right approach is the one that interests you the most.
Getting good at OOP will take some practice, but it is possible. Objects are like functions: they should do one thing well. Enforce separation of concerns. Learn the design patterns. Practice makes perfect(-ish).
Recommended Reading:
Your foes are kids in their twenties with a degree which takes years to achieve, this will be tough! But I think your age and your willingness to learn will help you lot.
​
Other things to learn:
​
If there's one framework to look at, it would be spring: spring.io provides dozens of frameworks, for webservices, backends, websites, and so on, but mainly their core technology for dependency injection.
​
(edit: other important things)
Disclaimer: This may not be true for your job, but it has been for every job I have worked at.
That everything they are teaching you about algorithms will not be useful to you when you get into the field. Your education starts day one at your first job. Clients don't pay us to innovate in algorithms. They pay us to find and glue together other peoples libraries and to use this to present them the requested information.
Code you will actually be writing:
Things you will be doing that CS degree does not prepare you for
I would suggest reading books like Design Patterns, Mythical Man-Month and Code Complete
That book is sort of an applied version of the "Design Patterns" book by the "Gang of Four" that is frequently mentioned by the author. The "Design Patterns" book is an excellent reference book to have on hand that I would recommend to any developer. I have both books and of all my programming books (and I have a lot of them) they are probably my two favorites out of the bunch.
Boot camps might help teach certain technologies, but they might not help with the fundamentals. Additionally before you give money away try to complete courses on Udemy or Coursera to see if you can commit to the effort.
Over simplified recipe for building skills to transition:
If any buzzwords here might not make sense, congrats you get your first exercise in digging for answers ;) (no rudeness intended)
You should first learn the patterns and then apply them to what you're doing:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Probably not as useful to go the other way.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
I would suggest checking out design patterns if you haven't already. Even if you don't find direct applications of patterns in your project, you will probably gain some insight into good oop techniques. Check out the gang of four book or headfirst design patterns.
> Books that old are also unlikely to talk about Design Patterns
The original GoF book was published in 1994.
One thing that may help is to read http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&qid=1344312820&sr=8-1&keywords=design+patterns
And like someone else said, try to make something that interests you such as a simple text based game or simulation or something, and you'll learn good design over time.
Coding Style:
Currently there is a lot of discussion about the PSR-1 and PSR-2 standards. The PSR-0 is definitly something which you should know about and follow it.
OOP structuring, Design Patterns:
Understand design-patterns (the standard book on this topic by the gang of four), and have a look into the topics of MVC and dependency injection. Zend Framework 2 and Symfony2 are the two major frameworks in this context.
Maybe also learn to know how database patterns like ORM and/or Active Record work. (Frameworks like Doctrine2, Zend_Db,...)
Test Driven Devlopment:
Check out PHPUnit and Behat for Behaviour Driven Testing
Version Control:
Our teams (2-8 programmers) work with both Subversion and Git. I recommend to check out both. Each has its disadvantages and advantages. There is a lot of discussion out there.
Related to this is the knowledge of Continous Integration and the connected tools. (Keywords: Jenkins, Bamboo, phpUnderControl, Hudson)
Read books. It might be boring, but a lot more informational than watching a youtube video.
If you already know how to program in another (preferably OOP) language there's The C++ Programming Language or C++ Primer if you want to learn C++11 (not to be confused with C++ Primer Plus, which is a different book 'series')
If you don't know how to program and you want to learn C++ for game development there's Beginning C++ Game Programming, which starts at the beginning (variables are one of the first things explained). After that book you should read up Introduction to Algorithms to make sure you're not writing horrible inefficient programs. Then there's Design Patterns: Elements of Reusable Object-Oriented Software to teach you more about certain patterns used in programs design (needed when using Ogre3D for example. Ogre3D was 90% magic to me until I read about Design Patterns. :p As alternative to DP:EoROOS there's Head First Design Patterns, but it's Java-centric which is a whole other beast than C++.
After those books there's this Stackoverflow thread. Read the first answer (the gigantic list of books). The thread used to be a ton of comments (with the most votes comments on top), but all anwers got copied to the first comment, so it's all sorted on votes. Code Complete (2nd edition) was the most upvoted one, The Pragmatic Programmer was the 2nd most upvoted one, etc.
Then there's this Stackoverflow thread, which is more C++ centric.
I hope this helps :)
For someone so spread out, one of the best things you can do is get a book about design patters / principles, as those theories spread across multiple languages.
General : http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?s=books&ie=UTF8&qid=1345469375&sr=1-1&keywords=design+patterns
This was a decent one for PHP: http://www.amazon.com/Objects-Patterns-Practice-Experts-Source/dp/143022925X/ref=sr_1_1?ie=UTF8&qid=1345469244&sr=8-1&keywords=php+design+patterns
Generally the Adapter Pattern is what you're describing, but it could also be used in combination with a Façade or other Structural Patterns from the Gang of Four book.
So in this case,
IBridge
corresponds toImplementor
Bridge1
andBridge2
correspond toConcreteImplementor
AbstractBridge
corresponds toAbstraction
(you can tell because it's the only thing with a field, andAbstraction
is the only thing with a field in the pattern)IAbstractBridge
doesn't correspond to anything in the patternRefinedAbstraction
from the pattern isn't present in the C# codeIf you want to go deep into the world of patterns, I highly recommend picking up the GOF book. It has 8 pages on the bridge pattern, including an example of supporting multiple window systems without suffering from combinatorial class explosion.
“Gang of Four” It’s the original design patterns book.
Like lots of new things, they got over-used. And misused.
Design Patterns: Elements of Reusable Object-Oriented Software
https://www.amazon.com/dp/0201633612
The Pragmatic Programmer
Design Patterns
Game Programming Patterns
These are books I actually own and would recommend. Of course there are other great/better books out there, but I'm going to stick with what I've actually bought and read or "read".
I say "read" because several books are NOT meant to be read cover-to-cover. These typically have about 1/3 that you should read like normal, and then skim the rest and know what's in the rest so that you can quickly reference it. These books are no less important, and often even more important. I've marked these kind of books as #ref for "read for reference". Normal books that should be read cover-to-cover are marked #read
For learning your first language: This is really the hardest part and unfortunately I don't have any books here I can vouch for. I started with "C++ for Dummies" and am not including a link because it's bad. Your best bet is probably "Learning <language>" by Oreily. I also love the Oreily pocket books because you can carry them and skim while on the bus or the john, but you can just do the same with your smartphone. Pocket Python, Pocket Java, Pocket C++
Top Recommendations:
Accelerated C++ #read Made for people who already know another language and want to pickup C++. Also great for people who need a refresher on C++. I really like how it doesn't start with OOP but gets you familiar with the imperative parts of C++ before diving into OOP.
The Algorithm Design Manual #ref This is my new favorite book and the first I would send back in time to myself if I could. Each algorithm & data structure is given a mathematical breakdown, pseudocode, implementation in very readable C, a picture (very helpful), and an interesting war story of how it Saved The Day.
Cracking the Coding Interview #read I originally avoided this book like the plague because it represented everything I hate about coding interviews, but many interviewers pull questions straight from this book so this book can equal getting a job. Put that way, it's ROI is insane.
The Pragmatic Programmer #read Must-have for any profressional software engineer that covers best-practices for code and your growth. You can also find the raw tips list here
Head First Design Patterns #read Many prefer the "GoF/Gang of Four" Design Patterns which is more iconic, but Head First is a modern-version using Java to cover actual design patterns used day-to-day by programmers.
For Intermediates:
Effective Java or Effective C++ and Effective Modern C++ #read When you're ready to go deep into one language, these books will give you a huge boost to writing good Java and C++.
Design Patterns #ref You'll want to get this at some point, but early on it's too much for a beginner and many of the patterns are obsolete.
The Art of Computer Programming #ref The programming "bible" but like Design Patterns you should hold off on this iconic book until you've got your basics covered. It would make for a great purchase with your first paycheck or first promotion :)
Regarding a dictionary: not that I know of, no unfortunately.
Also no, programs are not always laid out in the same fashion. There are the concepts of design and architecture. For the purposes here, I'm going to define architecture as how the entire system/program is put together, from the highest-level. Often this involves modules that each contain multiple classes (in OOD). Design, on the other hand, I'll define as how a small number of classes, within those larger modules, are related and interact. This is usually a class diagram in UML. Large scale vs. small scale essentially.
Architecture's goal is reducing risk and ensuring that the application/system exhibit certain non-functional requirements (or quality attributes in SEI-speak). These are '-ilities'. E.g., security, maintainability, modifiability, testability, but also time-to-market, performance, etc. One of the things to remember with architecture is that it encompasses not only the compile-time structure of the code, but also the runtime structure, the deployment (systems-level) structure, and the relationship to other systems (context) and, potentially, time.
While design also influences (and is influenced by) the non-functional requirements, it also concerns itself with data encapsulation: what data should be contained within what objects and how should it be accessed and modified, how tightly coupled and cohesive they should be.
Suggestions for architecture books (these are the two I have personal experience with):
Suggestions for design books:
If you did the Princeton Algorithms course and have two years experience as a professional developer you're way too advanced for CS50 and other intro classes.
The classes I'd recommend for someone in your position are:
More than the above though I'd recommend learning the following concepts and subjects even though there aren't any good MOOCs on them (to my knowledge):
Personal opinion: for language-specific books, the hands-on ones are the only ones worth reading.
If you want "bedtime reading", I'd suggest books that are broader than learning a specific language. Books that discuss algorithms, or design patterns...stuff like that.
Speaking of design pattern books...https://www.amazon.com/dp/0201633612/ Not sure how much mileage you'll get out of that, but it's considered one of the best design patterns books that I've ever heard of.
I'm not sure what your background is, but if you haven't had any formal programming education, I believe we learned out of a book like this: https://www.amazon.com/dp/0201633612/?tag=stackoverfl08-20
One of the keys to good software is good design. Making a plan of action before you even start coding cuts back on the 'quick fix' solutions that make your code harder to work with later.
I don't think this is C# specific, but design is really something that is abstract from language specifics. If you're looking for something specific to the environment you're working in, I think material on best practice for the game engine you're using would be better. I have done application development with C# and C# scripts in Unity, and there are definitely differences in how I am able to make things interact, which impacts how I design my code.
I have two recommendations if you're wanting to expand your abilities in design:
As far as the book goes, I can't condone it, but there's probably PDFs out there. Sometimes it helps motivate to actually read through it if you've invested some money into it, though. I would recommend finding an old/used copy. An old version of the book should work just as well as an 'updated' version.
You may also find it useful to look into Agile/Scrum. It's all about documenting your development, and helps to organize what's been done and what needs to be done, as well as give you an idea of how long things take, which helps later with estimations. All these things are skills that will come in handy later, if you decide to pursue software as a career. Plus, it's all good habits that help facilitate good, clean code.
https://htdp.org/2018-01-06/Book/
https://mitpress.mit.edu/sicp/
https://mitpress.mit.edu/books/introduction-algorithms
https://www.amazon.es/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
https://www.amazon.es/Object-Oriented-Design-Heuristics-paperback-ArthurRiel/dp/0321774965
https://www.amazon.es/Design-patterns-object-oriented-professional-computing/dp/0201633612
In one year you will be properly equipped to look for a professional position :)
> Is this stuff obviousl once you program more? Is it the study of software engineering? Computer science? Where can I learn about it?
No you need to work at it, yes, yes and on the job. You can start of the journey of learning this stuff through study and continue through experience. However it is a journey without an end, the landscape is changing, mobiles are the latest new technology but in 10 years time we will all be programming on devices we haven't even heard about yet.
> I want to learn classical program structures that common throughout programs.
There are some common design structures, especially for OO design with the book by the Gang of Four being a foundational work in this area. However knowing the patterns is just the start, knowing when to apply them and why they work is much harder and again comes from experience.
I've been doing a lot of research lately on the best books in programming in general to start a blog about each one and their importance to an inspiring developer. These are two of the books which will help you greatly getting started on designing your first game.
The first book is completely about design patterns, you will need to learn about these as creating software in general requires knowledge of how specific design patterns work and when you should use those patterns. The second book in the list is a complete guide to creating a small sample game, albeit not in libgdx, it should provide you with enough material to get you started.
I also recommend the Game Programming Patterns and Game Engine Architecture books which were stated in a previous comment. I have both these books as well as the Game Code Complete book and will be buying the Design Patterns book I mentioned as it is the most highly recommended book for any developer.
A lot of doing java programming right is understanding how things are commonly (effectively) done in Java (and in languages with similar set of features).
Regardless of anyone's opinions, a lot of that has to do with learning common design patterns, mainly the ones on the Design Patterns book (gang of four; http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/). Although the patterns in the book are just the starting point, it seems to be pretty good in terms of getting you up to speed with what some people tried (and are trying) to do with the design patterns movement, although there is significant disagreement.
There is also concurrency. This is a big thing in Java. A lot of the design of libraries and frameworks in Java are about dealing with concurrency issues. Server applications have to inherently deal with it, and this is where Java is mostly used. Although it's also a language independent subject, it's worth studying it applied to Java. A commonly recommended book is this one: http://www.amazon.com/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/.
The issue with all of this is that what I'm basically telling you is that "a large part of learning how to program in Java is to learn how to program", which isn't very helpful on its own. However, it's something I believe a lot of people miss. The focus on the language can be (it isn't necessarily) a symptom of that.
Read a lot of books. Everything is usually available as a pdf on the internet and the ones that aren't are $10 to rent on Amazon. Here's the ones that I've read that relate to this project.
Java
Android
Programming in general
If you're looking to expand your knowledge and learn some of the more advanced concepts, then read the following books:
gratz. After you are done with learning java, you might find this book useful: Design Patterns: Elements of Reusable Object-Oriented Software
I have no formal training in CompSci, but this book seems like a pretty standard 1st or 2nd year text. It's one of the best technical book purchases I ever made, imho: Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process by Craig Larman. I would recommend it to anyone who wants to learn programming. Goes great with the classic "GoF" book, Design Patterns. For any particular language's syntax and libraries, I just read the docs and check stackoverflow or IRC for any tricky idioms and for best practices.
What about some classics like Uncle Bob talks?
A lot of good design focuses on decoupling and creating components which work together but separately also.
Id first look into language agnostic design principles such as SOLID
https://youtu.be/TMuno5RZNeE
https://youtu.be/zzAdEt3xZ1M (golang)
A good book will help.
https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
I still keep a copy of the Gang of Four book at arms reach even tho the popularity is dwindling as OOP is not topic of most convos today. However when dealing with DI and sharable components in Golang, i find myself still falling back to abstract factories patterns. Its a good breathe of knowledge to at least glimpse at the patterns here:
Design Patterns: Elements of Reusable Object-Oriented Software https://www.amazon.com/dp/0201633612/ref=cm_sw_r_cp_api_i_7BzvDbXJC5WS4
Once you get thru these topics, you can start picking up what I consider the "hot" architectures of today:
Microservices, event based systems, domain driven design, event sourcing, and architectures aiding themselves to functional programming.
I really enjoy reading Martin Fowler blog posts: https://martinfowler.com/tags/application%20architecture.html
He covers a lot of these topics.
PS: maybe a niche and a personal favorite of mine but ive learned ALOT by researching the different types of kernel architectures. Nothing really geeks me out like those topic, but not for everyone.
A fabulous free course exists on these topics:
https://www.udacity.com/course/advanced-operating-systems--ud189
Design patterns are simply canned OOP designs for commonly encountered forms of different problems. Design Patterns is a seminal text. It's worth pointing out that design patterns are not a gospel for developing software, but you will inevitably run across some of them and should be able to recognize a given design pattern when you see it.
That's what I get for being snarky. ;-)
There's another excellent book called Design Patterns that predates the Uncle Bob one, if you'd like to learn some history on the pattern.
I don't know of any others from personal experience that I can vouch for. A quick search on Amazon returned this book, which has good reviews and might be worth looking into.
https://kindle.amazon.com/work/design-patterns-elements-reusable-object-oriented/B000B10F30/0201633612
https://kindle.amazon.com/work/design-patterns-elements-reusable-object-oriented/B000B10F30/0201633612
http://www.amazon.com/gp/aw/d/B000SEGEKI
>> You literally get what you pay for when it comes to books.
I like these:
http://www.amazon.com/gp/offer-listing/1585009709/ref=dp_olp_used?ie=UTF8&amp;condition=used
http://www.amazon.com/gp/offer-listing/0201633612/ref=sr_1_olp_1?ie=UTF8&amp;s=books&amp;qid=1248674286&amp;sr=1-1
http://www.amazon.com/gp/offer-listing/0596528124/ref=sr_1_olp_1?ie=UTF8&amp;s=books&amp;qid=1248674320&amp;sr=1-1
Most remember it purely through repeated use. You honestly only need to know the following about any data structure or algorithm:
Here's a good google search to use: stack overflow <insert-data-structure-or-algorithm-here> applications
That should return a good list of links which should provide further information about whatever you're searching. Don't feel bad to google information, that's much better than attempting to rote memorize information.
Also: here's a good book on object-oriented design that I'd recommend which covers typical design patterns.
https://www.amazon.ca/gp/product/0201633612
In terms of books, i think this is all you need. Read the intro, and do as it says, don't memorize it, just understand the ideas behind the concepts and come back to them when you need them.
> how do you avoid forgetting rarer patterns, so you can still use them in new designs?
I wouldn't worry about that. You should not memorize the patterns, just know them and understand them. Understanding them comes with practice, use them enough and you start to see why this is good. It's like formulas in math, at first you memorize them, eventually you understand them, eventually you can derive them.
Same idea with patterns, once you have enough experience and practice with them, you don't have to worry about the lesser used ones since you will probably have some notion of it. Just read what the structure/goal behind it is and everything should come to you naturally.
Depends what industry you work in, game design will employ other patterns more often than say building some saas web app.
But as long as you know the major ones well, the rest tend to be variations or extensions. Like Factory and Delegator. Delegator is essentially a Factory.
Factory is one you should know, singleton, mvc, facade etc...
Crap! I just ordered this book from amazon. Had I known about this free book I would not have.
Design Patterns is the de facto standard, although Design Patterns Explained is probably better as an introduction.
Reading up about design patterns will give you some more abstract ideas about how you might construct programs, particularly object oriented. This book's a bit of a bible in that regard.
That's not what I meant, sorry if I came off that way. My point is, you can read all the books you want -- but if you don't supplement it with code you write, they're just concepts. Even if you're not writing code, you still should be looking at pseudocode or example code to see how it's implemented. Talking about something is easy -- programming it is hard. What people say when they say to design first, they mean to lay out your program, your APIs, and everything else ahead of time. This is part of professional software development. In order to get to that step though, you're going to have to program. You don't recognize good OO or game design by just reading a book.
Regardless, for a good OO-book, check out:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
For a good book on game engine design, check out:
http://www.amazon.com/Game-Engine-Architecture-Jason-Gregory/dp/1568814135
If you want just game design and setup, there are more than enough resources at /r/gamedev.
Also, make sure to supplement everything with code you yourself write, or else nothing will stick.
you could always buy the bible: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_5?ie=UTF8&amp;qid=1425602201&amp;sr=8-5&amp;keywords=gang+of+four
otherwise, http://en.wikipedia.org/wiki/Software_design_pattern
Can you suggest a website? Is this an example of what you mean? Or could you recommend a book? Is this a good example?
These books will bring your design skills up a notch and give you some material to back up your arguments in design disputes.
Design Patterns (Head First).
It's the "gang of four" patterns covered in a somewhat silly way to help you learn it. Teaches you some very good stuff.
I'd get the gang of four book for a reference, but get the Head First one to learn them first. It's not precisely pure OO, but it teaches you concrete ways to apply good OO practices, such as (the most important one IMHO) favoring composition over inheritance.
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
100 Rogues didn't require anything fancy. I tried using some AI algorithms that sounded cool, but if / elses served the design way better, once they were organized. If you're looking to learn how to turn the basics into larger projects, I'd read up on design patterns.
The bible: http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&amp;qid=1376607225&amp;sr=8-1&amp;keywords=gang+of+four
90% of the heavy lifting in 100 Rogues is a combination of Command and Observer patterns from that book.
Gang of Four; an industry nickname for the four authors who wrote this book
Coming from a programming perspective, I would be happy with this book, Design Patterns by The Gang of Four (http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612).
It's more programming related but still very useful for game developers.
This is THE reference on OOP patterns. And I mean *THE* reference: Design Patterns
I highly recommend it.
Not sure what language you are working in, but if it's an OOP then this book is father of code design. You can surely find something similar that's specific to whatever language you are working in also:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Make sure you comment really well and use naming conventions that make sense. Read about encapsulation, loose coupling, and inheritance. I just make sure you continue thinking about it until it becomes second nature and you have solid habits.
It's not even for a team thing, it's even for yourself. Eventually you'll go back to an old program and realize you have no idea what's going on.
EDIT: accidentally a word
>mostly because you need to be good at a lot of mathemtics, is this true?
This is primarily for algorithms. It's pretty easy to be good at math, the hardest part I find for people who program is that they often don't think "outside the box" in breaking their program down.
I and others recommend programming in C#. You should be able to get off the ground with the following resources:
http://learncs.org/
https://mva.microsoft.com/en-US/training-courses/software-development-fundamentals-8248?l=D9b9nHKy_3404984382
https://mva.microsoft.com/en-US/training-courses/c-fundamentals-for-absolute-beginners-8295?l=bifAqFYy_204984382
http://www.amazon.com/Exam-98-361-Software-Development-Fundamentals/dp/047088911X
This list is for programming in general:
http://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1453520022&amp;sr=1-1&amp;keywords=pragmatic+programmer
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1453520045&amp;sr=1-1&amp;keywords=clean+code
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1453520067&amp;sr=1-1&amp;keywords=gang+of+four
http://www.comp.nus.edu.sg/~stevenha/myteaching/competitive_programming/cp1.pdf
http://visualgo.net/
http://www.sorting-algorithms.com/
http://code.tutsplus.com/tutorials/3-key-software-principles-you-must-understand--net-25161
I've been trying to read everything and anything that interests me. You probably need a reading list of some sort. One book I can recommend right now is Design Patterns: Elements of Reusable Object-Oriented Software.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Design Patterns is a classic textbook on the subject.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Unfortunately, I don't know any good free resources.
"Design patterns" are the function use of oop so from a learning perspective I would suggest starting there (assuming you understand the fundamentals of programming of course)
I loved head first design patterns but the GoF book : Elements of Reusable Object-Oriented Software is pretty awesome albeit a bit heavy for learning.
Coding:
Object Oriented Programming (OOP):
EDIT: People who are downvoting this are doing you a disservice out of ignorance. You must read Code Complete 2.
Would this be the book?
we use the whiteboard for that. until he can read this:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
and k&r on his own, I will be teaching him
How about the Gang of four
It is a good book too.
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
The gang of four book.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Is this the book, "Design Patterns", that you were referencing?
First note that Career/Job/Market is quite different from Knowledge/Intellectual satisfaction. So you have to keep "earning money" separate from "gaining knowledge" but do both parallely. If you are one of the lucky few who has both aligned in a particular job, you have got it made. Mostly that is never the case and hence you have to work on your Motivation/Enthusiasm and keep hammering away at the difficult subjects. There are no shortcuts :-)
I prefer Books to the Internet for study since they are more coherent and less distracting, allowing you to focus better on a subject. Unless newer editions are reqd. buy used/older editions to save money and build a large library. So here is a selection from my library (in no particular order);
Yeah I have read around 70%-80% of all YDKJS books combined .
By the way just in any case you find anything interesting and helpful (but for also copy pasting this list in the future) here are the books-site tutorials-docs that I am reading-have read-plan to read-follow :
web dev road map
htmldog
www.javascript.info
css in depth (manning)
eloquent js
YDKJS (all books)
HTML5 for masterminds
dom enlightenment
high performance images
web performance in action
reliable javascript
building progressive web apps
http: the definitive guide
learning http 2
cracking the coding interview
javascript data structure and algorithms (be careful,not a good choice, it has a lot of mistakes but I find it concise)
professional git
vs code docs
Using SVG with CSS3 and HTML5
Interactive Data Visualization for the Web
refactoring ui
figma docs
react docs
redux docs
vue docs
webpack docs
clean code
design patterns
web components in action
Inkscape: Guide to a Vector Drawing Program
and many more to come .
I think it depends on your location. If you live in or a commutable distance to a city with a strong technology sector, they will be quite a bit of companies willing to hire an high school level intern.
For example, a friend of a friend got an internship after graduating high school for the summer in the city he lives. I live outside the city and I am taking a year off before university because I got sick in the summer. I'm better now but all the companies near me are kind of old fashioned and they don't accept interns after a lot of cold calling; my calls and emails get sent to their HR manager, and they don't feel like giving me a chance. Also the benefit of an internship in the city for him was that he used pretty modern web development stuff.
As a high school intern unless you find a research group, you will highly unlikely use R. You can probably do front-end web development, so learning HTML, CSS, JavaScript, Jquery, and the Bootstrap framework would be awesome. If you don't want to do front-end web development, you really have to market yourself and make sure you are competent in Python if you want to use Python.
As a person who graduated high school last year and is taking a year before university to recover from an illness, I have to compete with other university students of various years who even the freshman have some sort of qualification as a candidate for a bachelor of applied science or math degree which tells the potential employer the applicant is knowledgeable. If you want to be competitive with the freshman or maybe the sophomore students, you really need a good GitHub portfolio which shows you are knowledgeable as them.
For example, in my GitHub portfolio, I have an Android application (GitHub and Google Play). In this small to medium sized application (35, 000 lines of code), I show I can use a version control system and a bug tracker by using Git and GitHub, respectively. Furthermore, in the bug tracker, I show I can debug by showing results of me using an allocation tracker, a heap dump analyzer, a GPU rendering profiler, and the like. In the actual source code, I show my experience with Java. But more importantly, I show I can implement an architectural pattern like Model-View-Presenter (a deviation from Model-View-Controller), some design patterns like wrappers, singletons, mappers, adapter, presenters, contracts, providers, and factories, and design an API which performs network requests, database queries, and file input and output. In the source code, I try to apply as much as I can from reading, Effective Java (2nd Edition), Clean Code: A Handbook of Agile Software Craftsmanship, Design Patterns: Elements of Reusable Object-Oriented Software, and Introduction to Algorithms while I get acquainted with reading Software Engineering: A Practitioner's Approach. I still need to try to utilize TDD and Agile practices; I read about them, but I never tried them out.
I think if you have a GitHub portfolio with project(s) of a good size that shows a lot of computer science and software engineering concepts, you will be ahead of most freshman students whose only projects might be a small class project in their Intro to Java class which all their peers did.
Currently, the application has around 5,000 downloads in about a month with 4.4 rating to place it 5th in its specific category above 4 stars on Google Play: https://play.google.com/store/search?q=Manga+Reader&amp;c=apps&amp;rating=1; it took about a month and a half. However, every time I send my resume to a local company outside the city for an internship, I get no response. I'm going to a Career Fair at a friend's university in the city on Friday, so I'm a test my luck there; they have quite a few recruiters for mobile application interns, and one company develops a full stack product and service whose mobile applications kind of match mine. Overall, it's feasible if you are near a city, willing to commute, and can prove you know as much as a freshman student who they could hire instead.
How about a new language? Or writing software rather than web stuff?
After doing webdev for a while I got in to offline Java (software) development. Aside from helping me tighten my grasp on real OOP, it also caused me to shift/alter some of my design patterns. Java itself can be extremely cumbersome to write, but the process of doing so definitely made me stop and re-think exactly HOW much I want to leverage the flexibility of other languages.
Writing Java also lead me to read books, from which I took lessons I could apply to other languages. These books in particular were helpful:
http://www.amazon.ca/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.barnesandnoble.com/w/data-structures-and-algorithms-in-java-robert-lafore/1100840388?ean=9780672324536&amp;itm=1&amp;usri=9780672324536
Obviously I'm just using Java as an example. If you already write Java, or feel great about your understanding of OOP, perhaps try a functional programming language? Lisp(Clojure)? Scala? The performance of some of these languages is really wild, and I'd think it would be possible to leverage their speed when working on large SAAS projects.
Anyways, to each their own. Obviously the other comments here have plenty of good suggestions. I know I certainly didn't regret getting familiar with SASS. And I could probably stand to spend time forcing myself to get more proficient with my editor. Right now I use Sublime Text 2, and I could either make sure I'm using all the proper key binds for traversing/manipulating text OR just go boss mode and make the switch to vim. Or even bite the bullet and use an IDE (http://www.jetbrains.com/).
Best of luck!
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Interview Cake
It is paid.
It is prepares people for coding interviews. Those will have the fundamental issues that you will need in your courses. It has pretty top notch for explanations and broad coverage. Many languages. High quality product. If you are having issues paying for it - maybe some of your coding friends might be interested in splitting the bill. You'll have to work out how ahead of time. Definitely sign up for the weekly email and do the problem.
&#x200B;
The other issue you may have is that you don't understand how the code fits together. Specific lack of understanding on how the design patterns work and fit together into architectural patterns.
Design Patterns: Elements of Reusable Object Oriented Programming
There are less than 30 of them. You should know them by pseudocode. Know which ones apply to which types of languages. It might take you awhile to really learn them. Use Anki to help review them on the toilet.
&#x200B;
The other aspect is software architectural design patterns. I don't have a book that I would recommend for that one. Not because I couldn't find one, I just haven't reviewed enough literature to point you in the right direction. There might be 20. There might be less.
&#x200B;
&#x200B;
Design Patterns: Elements of Reusable Object-Oriented Software (Gang of Four / GoF's book) is the bible of OO design pattern.
You can also find info here: http://c2.com/cgi/wiki?DesignPatternsBook
You can easily find info / samples / illustrations of the various design patterns if you just Google their name one-by-one though.
You probably don't need extensive knowledge of data structures for mobile apps, but I ALWAYS encourage learning data structures! Knowing what structures are available and when to use them is a bit like being a programmer super-hero and one of the things that really sets apart the self-taught hackers from the top tier engineers and scientists.
It's not a course, but I always love to plug my professor's book Open Data Structures. He's made it freely available in many different languages with code samples in multiple languages, and it's a really good read.
One thing I would highly recommend before getting into the mobile space, however, is looking into design patterns. The fundamental book on this is Elements of Reusable Object-Oriented Software by the Gang of Four, but there are some other ones I've found which are pretty handy. Game Programming Patterns is freely available, but it is a bit domain specific. It really nicely details a lot of patterns, however. JavaScript Design Patterns also really nicely details them and is also freely available.
You mentioned Robert Sedgewick. His book, Algorithms and his online courses are highly recommended. And he uses Java in them.
http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X
http://algs4.cs.princeton.edu/home/
For object-oriented design the Head First books are great. It also worth to have the classic book Design Patterns: Elements of Reusable Object-Oriented Software.
http://www.amazon.com/dp/0201633612
I also recommend the books Code Complete, and Clean Code, they are great.
CompSci covers a wide range of subjects, many of which won't be that relevant to you. When I was at Uni my classes covered:
This list isn't comprehensive, but covers most of the main points. For your job, you can happily ignore most of that core.
I think you'll want to focus on with the highest priority:
Warning: Algorithms is a heavy and dry book. It might not be a good recommendation for a beginner to be honest.
As you're interested in Data Science, you're already off to a good start with R and Matlab. Python is fine but has some issues that don't make it ideal for large-scale data processing. The good news is that once you've got the hang of Python, you can learn another language much easier. I think it's worth noting that R is quite obtuse in my experience, so if you get your head around that you're doing quite well.
But I digress. You're also going to want to learn about data structures, networked systems and databases, especially if you want to work with "Big Data". I think thought that your best starting place here is learning how to code. With that under your belt along with your math degree, everything else should be easy enough to learn on a case-by-case basis.
Source: Masters & PhD in CompSci subjects. Good luck, and feel free to PM me if you're interested in a mentor for this. With a better understanding of your position, I could probably help pare down what you need to study to more specific subjects.
PS: Assuming you're at Uni, your library should have both books I have suggested.
http://pixelshaders.com/
http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
http://mitpress.mit.edu/books/history-modern-computing
http://c2.com/cgi/wiki?ReallyValuablePages
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf
http://www.haskell.org/haskellwiki/Research_papers/Functional_pearls
http://www.glprogramming.com/red/
http://wiki.lesswrong.com/wiki/Sequences
Design Patterns is a land-mark work published in 1994 that captures some recurring, useful object-oriented designs.
Sorry but there's no cheat sheet and no reasonable way of making one. C++ is a rather large and complex language laid atop C, which is effectively laid atop an assembly language, which is compiler manufacturer and target platform dependant.
The best way to learn C++, or any programming language for that matter, is to use it, learn from your mistakes, and of course researching and reading everything you can. And of course, have fun with it!
Many popular books exist covering C++ things. Here are a couple good starter ones, in my opinion:
A couple popular C++ sites:
If you're simply starting to learn programming, start small. I suggest beginning with an object-oriented scripting language like Ruby, Python or Javascript. Most concepts will transfer to C++, but beware that the syntax will not - you will quickly see the difference!
First Advice! Don't listen to high school guidance counsellors.
You require certain high school courses to qualify for College or University programs. What you want (ideally) is a 3 Year University Bachelor's Degree in Computer Science with a Minor in Game Development. Figure out which schools you're interested in and what they require for admissions to their programs.
You're probably hoping to start making games now though, so I'll give you some advice on that.
Try to get a copy of this book: http://gameenginebook.com/
It's kind of a heavy book, both figuratively and literally, but it'll teach you everything about how a video game works. Even if you're not going to be building this or that part of a game, it's important to know how it all works and fits together.
This YouTube Channel Extra Credits has a lot of great video articles on game design and development, and links to other channels.
You can find a ton of guides on YouTube for computer programming, game design, 3D modelling, music, etc. The key word to search for is Tutorial.
Once you've learned how to program computers, you should read this book to learn how to program computers well: Design Patterns: Elements of Reusable Object-Oriented Software
It's a pretty old book, but that's because nobody has had reason to update it; it's just that good. That said, a smart fellow released a free web-based followup book for Game Developers here: http://gameprogrammingpatterns.com/
If you want to focus on Game Design I'm a big fan of Raph Koster so here's his book too: http://www.theoryoffun.com/
I guess the rest is up to you. Any specific questions?
If you finish up the other books, you could read Design Patterns and The Pragmatic Programmer. There will be some overlap with the first two books I mentioned, but I think it can be helpful to read about the same topics from different points of view. I would probably read Clean Code and The Pragmatic Programmer straight through. The other two can be used more like reference books. Although, be sure to practice the design patterns you learn from the reference books.
There are programming exercises that you can use to practice patterns. Look up coding katas and see what you can find. Start with Gilded Rose. There are multiple ways to refactor this code, so it's a good one to practice. Here's another one.
If you were serious about wanting some deep as-you-go knowledge of software development but from a Pythonic point of view, you cannot go wrong with following a setup such as this:
Mark Lutz writes books about how and why Python does what it does. He goes into amazing detail about the nuts and bolts all while teaching you how to leverage all of this. It is not light reading and most of the complaints you will find about his books are valid if what you are after is not an intimate understanding of the language.
Fluent Python is just a great read and will teach you some wonderful things. It is also a great follow-up once you have finally made it through Lutz's attempt at out-doing Ayn Rand :P
My recommendation is to find some mini projecting sites that focus on what you are reading about in the books above.
Of course this does not answer your question about generic books. But you are in /r/Python and I figured I would offer up a very rough but very rewarding learning approach if Python is something you enjoy working with.
Here are three more worth adding to your ever-increasing library :)
Does anyone know what would be best to prepare me for interviews for new-grad interviews that'll probably open during Fall 2019? I don't think it's that important to have side projects as I have internships/experience under my belt, so I just want to be studying/enhancing the foundation I have. I currently own CTCI and The Algorithm Design Manual. I'm planning on getting the Gang of Four Design Patterns, but I'm not 100% yet. Anyone know any good resources for System Design? Any feedback on how should approach this preparation? I know it's super early, but better early than late.
I'm surprised Design Patterns: Elements of Reusable Object-Oriented Software isn't on the list. Old (1994), but gold.
Try http://codingame.com. Pretty fun in short bursts. Books are still good resources. Try out https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612. Do you like playing games? Try making a crude remake of the simplest game you enjoy. Maybe a poker clone...then add an AI.
I've heard good things about Design Patterns: Elements of Reusable Object-Oriented Software and Head First Design Patterns. Haven't read either yet myself, but they're on my todo list.
Design Patterns
The Art of Computer Programming
The game piece example is about using singleton to, yes, conserve memory, with simple data types. For instance, you'll note that ruby itself, analogously, uses it with integers.
101
is always exactly the same object in ruby (which is necessarily immutable for that reason; in general, singletons that have any mutable state at all are going to give you nightmares, especially under concurrency). (You can verify this checking101.object_id
, always the same for any101
anywhere in a program execution. This is not true for string"101"
, which is of course also mutable).In the "Gang of Four" book, which introduced the notion of "design patterns" in programming as well as the "singleton" pattern specifically -- I think this particular pattern would actually be identified as the "flyweight" pattern, rather than "singleton", although it's implementation might in this case be in terms of singleton.
I probably wouldn't be likely to actually implement a chess game that way. I think the "flyweight" pattern is pretty specialized in contemporary programming, where RAM is a lot more bountiful compared to when the GoF was writing. The times you need to conserve RAM this way and it's worth the added complexity are probably rare (although probably not never ever encountered).
Here's pretty much your most basic flow for problem 3:
To troubleshoot, use a debugger (Eclipse's builtin is nice). If you feel it's taking too long, break the program's execution and check its state. Is the loop counter about where it should be? Are the found divisors plausible? Is the loop end target plausible? Set a breakpoint on the first line inside the loop and keep stepping through (either one line at a time if you like, or just hit 'resume' and it will break again at the top of the next loop iteration).
I learned Java throughout college, as it was the primary teaching language. Honestly, the best way to learn is just to WRITE CODE. Solve problems that you don't know how to solve. Invent random things that are useful to you. Your code doesn't have to be perfect when you're learning (and it definitely won't be!), and what is important is that you constantly look for ways to improve. I want you to look back on code you've written a year ago, and think that it's absolute crap - that will show that you are learning and improving.
Somewhat counter-intuitively, the best resources are books! I'll list some recommendations below.
Keep these principles in mind:
Once you start getting a feel for Java, which I think you might be already, Effective Java is the book. You probably won't need any other resource for Java itself.
If you need help with something, Reddit is a great place, but Stack Overflow is the programmer's mecca. The best resource on the web for just about everything software, and their sister sites cover other topics, from IT/sysadmin to gaming.
Well, even with your disclaimer, I would still strongly recommend that you give CC2 a readthrough. Don't worry about understanding every bit of it, but get a lay of the land.
Other books you should read include:
http://www.amazon.com/Algorithms-4th-Edition-Robert-Sedgewick/dp/032157351X/ref=sr_1_1?ie=UTF8&amp;qid=1405474488&amp;sr=8-1&amp;keywords=algorithms
http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?ie=UTF8&amp;qid=1405474502&amp;sr=8-1&amp;keywords=head+first+design+patterns
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_2?ie=UTF8&amp;qid=1405474514&amp;sr=8-2&amp;keywords=gang+of+four
I would read them in that specific order.
As someone making the switch (I start my new Developer role later this month):
Gang of Four is the standard for design patterns.
cant believe nobody has mentioned design patterns yet.
Design Patterns is called "The Bible," also called the "GoF Patterns" aka "Gang of Four"
Some people like Head First Design Patterns as an introduction (it has better code examples), but if you end up wanting something more information dense/rich then try the GoF.
You might try to fit your work in design patterns ( start with the gang of four ;) ) and code the structure UML style.
Take one of your old projects and use umbrello (only for linux) to port it to UML. Check if you can make it more simple,better or fit in a design pattern. And don't go to the other edge -in this way of programming you get clean and organized structure but you need more time (and sometimes code) to get a result.
Also, get a task manager like taskfreak and write a todo list with deadlines.
And as dmazzoni advised: use github.
Personally I'm very partial to Design Patterns: Elements of Reusable Object-Oriented Software. I see Java more and more as a software engineering, rather than a programming language. You can do programming more effectively in Python/Jython or (J)Ruby, but Java for me still is king for developing type-safe, robust libraries and unit testing.
You might also want to read up on Eclipse or another decent IDE. Eclipse reduces the amount of monkey typing that all Java developers must endure dramatically with things like templates, getter/setter generation, delegate method generation etc. Since the editor parses the code as you type and keeps an AST in memory, refactoring support is excellent and you'll spend less time worrying about minor design issues when starting a new project. Code is compiled on the fly so startup times are minimal. It's also able to produce very descriptive and useful information about any errors you might have in your code (unlike GCC, for instance:)
If you want to know a bit more about how the JVM itself works, read The JavaTM Virtual Machine Specification, Second Edition which is online and free. It'll give you a bit more insight into why some crappy things are as crappy as they are (backwards compatibility with Java 1.1). Read books that are recent enough to include language features of 1.5 and 1.6, such as static imports, enums, generics, varargs and so on, and decompile some Java code to see how the compiler implements them.
The Data Warehouse Toolkit: The Complete Guide to Dimensional Modeling (Second Edition)
Design Patterns: Elements of Reusable Object-Oriented Software
Good stuff.
While it's not specifically game related this book has been an excellent resource for me as far as patterns go.
Also, flyweight rox!
Read https://www.amazon.co.uk/Design-patterns-elements-reusable-object-oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&amp;qid=1462540508&amp;sr=8-1&amp;keywords=design+patterns
So many things in this book are immediately noticeable in many of the large frameworks. Model-View-Controller is a really common pattern.
Actually the biggest things to learn for me were testing related however. Test-driven development is an awesome habit to pick up - really changes how I design code.
I would focus more on deciding what you want to make. When you can make something that works, you're a programmer. When your code isn't brittle, is well commented/documented, is "clean" and other devs can understand and work with it, you're a good programmer.
So pick something you want to create and make it: a website, a simple program, a game, etc.
How to go about it? Once you have that thing you want to make, break it down into bite size tasks and start tackling them one at a time. First, you'll need to figure out what language and libraries you need (or want) to use. Then set up your dev environment and get a "Hello World" example to work. Then just start building piece by piece. Once it works, make it work better (i.e. refactor it).
I use a bunch of resources to be a better programmer:
I hope that helps.
There are a ton of books, but i guess the main question is: what are you interested in? Concepts or examples? Because many strong conceptual books are using examples from java, c++ and other languages, very few of them use php as example. If you have the ability to comprehend other languages, then:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=sr_1_1?ie=UTF8&amp;qid=1322476598&amp;sr=8-1 definetly a must read. Beware not to memorize it, it is more like a dictionary. It should be pretty easy to read, a little harder to comprehend and you need to work with the patterns presented in that book.
http://www.amazon.com/PHP-5-Objects-Patterns-Practice/dp/1590593804 - has already been mentioned, is related directly to the above mentioned one, so should be easier to grasp.
http://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420/ref=sr_1_1?ie=UTF8&amp;qid=1322476712&amp;sr=8-1 - one of the most amazing books i have read some time ago. Needs alot of time and good prior knowledge.
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672/ref=sr_1_4?ie=UTF8&amp;qid=1322476712&amp;sr=8-4 - another interesting read, unfortunatelly i cannot give details because i haven't had the time to read it all.
Lots of books and videos cover it well. You can find lots here also: http://www.oodesign.com/
Also this classic book many people recommend:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
My advice is:
I was in the same boat as you 3 years ago. CS degree anddd thousands applying for the same position as me. Luckily i got a job in the end. Started applying 3 months before i finished my exam. Ended up getting a job straight after finishing my exams as a junior software developer. :)
Get an MS degree. I had a BA in Psych and went straight for MS in Comp Sci. Not every school will allow it and the ones that will will require you to take a couple of undergrad courses and pass them with B or higher.
That being said - if you still prefer to go the no degree route you're going to have somewhat of a tough time with interviews even though you may perform the job well itself. Most software engineering interviews revolve around things like how a hash map works and properties of binary trees - information you aren't usually going to get from the "build your own iphone app" type books. So I would recommend:
Good luck!
This book reference gets overused, but Design Patterns was a change for me in the whole way I saw code. It's not easy to get through and some of the patterns take several reads for the lightbulb to go on, but once you get a design pattern, that knowledge stays with you through any OO language, not just C++. The patterns in the book are things that you run into all the time in programming, and that spidey sense of "I've seen this before" when you're working through the design of a problem is beyond valuable. Knowing what the patterns do, and more importantly, when it's appropriate to use them, is a key differentiator especially in C++ programmers.
Technically, for C++ specifically, knowing your stuff on memory management is a highly valuable. Not just how memory management works, but what are the best practices? Who is responsible for freeing the memory if a function creates a new instance of an object and returns a pointer to it? How do you know that all references to an object are out of use once an object is released from memory? (I saw smart pointers referenced before) When do you have to zero-init alloc'd memory and why? alloc, free, calloc, realloc, new, delete, learn all of that memory management stuff.
All I could recommend you are the texts I picked up in college. I haven't looked for any other resources. That being said:
http://www.amazon.com/Computer-Organization-Design-Fifth-Architecture/dp/0124077269
This text is really only useful after learning some discrete math, but is THE book to learn algorithms:
http://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
This one wasn't given to me in college, but at my first job. Really opened my eyes to OOD & software architecture:
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
I own all of Robert C. Martin's books, except for UML for Java, as well as Martin Fowler's Refactoring (the white one), PEAA, DSL and Analysis Patterns. I also have Refactoring to Patterns, Code Complete and Design Patterns (aka go4) and a few others.
I would suggest Refactoring to Patterns is the one you are looking for, but that expects you have a working knowledge of what the patterns are already (likely with your experience though you may not know them by name). I don't think that is strictly necessary but it will help you understand why you might want do do things the way being suggested in the book. The examples are in Java, but they apply to C# just as much. His site is here: https://industriallogic.com/xp/refactoring/ and he has the code up behind an online course / paywall (I have not looked into this).
In a greenfield environment, tdding up an application from a blank project Uncle Bob or Fowler's pattern books are probably better, but from the perspective of an existing codebase I think Kerievsky's Refactoring to Patterns and Fowler's Refactoring are best.
I find more often than not that patterns are rarely well represented in books; they are almost always delve too far into implementation specific details or simply gloss over any implementation details in favor of theory. Sometimes, all I want is an ELI5 about the pattern, and let me work the rest out for my codebase.
Books on principles of coding, however, are dime a dozen. One I like in particular is Adaptive Code via C#. It gives plenty of code examples (you can download the entire working solution projects from the website given in the book) and it does a fair job of covering several patters and gives specific examples of how they apply to the SOLID principles.
Of course, there's always Design Patterns: Elements of Reusable Object-Oriented Software. This book has been one of the programmer's bibles for the past 20 years. It is a more difficult read, since it is a more theory oriented book. One thing to note is that some of the design patterns discussed in the book have been rendered obsolete by aspects of some languages and frameworks, while a number of new patterns have come to exist based on those same languages and frameworks.
> Unity seems to be encouraging this weird hybrid style.
This isn't actually true, there are lots of weird implementation details but there is nothing weird or hybrid about Unity's design. It's just not a data-oriented ECS. The Unity pattern is a variation on the Composite Design Pattern from this book:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Code every day. Work on as many little interesting projects as you can. If you don't know any languages I'd suggest starting with Python, there are a million different tutorials and resources online, so getting started shouldn't be a problem.
Add to that, read some books to learn about how software development projects work, different techniques, best practices, pitfalls, etc. Here are my recommendations on books: The Pragmatic Programmer, Refactoring, Code Complete (a bit dated, but still solid), Rapid Development (slightly mis-titled, it's a good overview of different development practices), The Architecture of Open Source Applications, and Design Patterns. Code as much as you can, be ambitious, be analytical and introspective about the problems you run into, and read and understand those books too. There's a lot more you'll need to learn to become a good developer, but what I've described will give you a very strong base to build on.
Oh, and if you don't already know discrete mathematics you'll need to pick that up. I'd recommend this book.
This one is one of the most (if not the most) popular book of C++ design patterns.
If you didn't like the style of Head First, the GoF book is a more formal option.
No, it isn't. Wikipedia is, like usual, because it's written by people who learned what MVC means from random frameworks that also get it wrong.
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Get the original book, at least skim it and remember the type of problems it helps you fix. You don't need to memorize it, but it also just helps thinking about software more abstract:
https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
Also as you said, there are a lot more now. A lot of new trends came and went since then. But this is a really good foundation. On top of that you can read up on whatever is relevant for your projects.
I would assume digital design has to do with software planning, i.e. making UML diagrams and such. You will also most likely be expected to know the basics of design patterns, and you should check out this book.
http://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670
http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612
http://www.amazon.com/Modern-Design-Generic-Programming-Patterns/dp/0201704315
http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672
http://www.amazon.com/Coding-Standards-Rules-Guidelines-Practices/dp/0321113586
Also if you want something really challenging:
http://www.amazon.com/Computer-Programming-Volumes-1-4A-Boxed/dp/0321751043
http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871
Free below:
https://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html
...continued...
> Test plans - When you apply for QA roles, you'll almost certainly be asked "how would you test ____?". The correct answer is to be methodical. Don't just spew out a stream of test cases as you brainstorm them. Understand the different scopes (unit, functional, integration, maybe end-to-end) and what the goals of each is, and how they differ. Understand that there are different areas of testing like boundary, happy path, special cases (null, " ", 0, -1), exceptions, localization, security, deployment/rollback, code coverage, user-acceptance, a/b, black box vs white box, load/performance/stress/scalability, resiliency, etc. Test various attributes at the intersection of a compenent and a capability (borrowed from the book How Google Tests Software), and I believe you can see a video that goes into this called The 10 Minute Test Plan. Understand how tests fit into your branching strategy - when to run bvts vs integration vs regression tests.
> Test methodologies - Understand the tools that make you an efficient tester. These include data driven tests, oracles, all-pairs / equivalency class, mocking & injection, profiling, debugging, logging, model-based, emulators, harnesses (like JUnit), fuzzing, dependency injection, etc.
> Test frameworks - Knowing all the tests you need to write is good, but then you have to write them. Don't do all of them from scratch. Think of it as a system that needs to be architected so that test cases are simple to write, and new functionality is easy to implement tests for. I can't recommend any books for this because it's something I learned from my peers.
> Test tools - Selenium / WebDriver for web ui, Fiddler for web services (or sites), JUnit/TestNG, JMeter (I have to admit, I don't know this one), integration tools like Jenkins, Github/Stash, git/svn.
> System design - As you're entry-level, this may not be a huge focus in an interview, but know how to sensibly design a system. Know which classes should be used and how they interact with each other. Keep in mind that the system may evolve in the future.
> Whiteboarding - Practice solving problems on a whiteboard. The process is more than just writing the solution, though. This is the process I follow (based loosely on the book Programming Interviews Exposed):
Resources:-
> Learning to test:
> Learning to interview:
> Learning to program:
> Miscellaneous
> What sort of skills should I really hone? I realize I gave you a ton of stuff in this post, so here's a shorter list:
> Examples of projects that make you look valuable