Reddit reviews Head First Design Patterns: A Brain-Friendly Guide
We found 150 Reddit comments about Head First Design Patterns: A Brain-Friendly Guide. Here are the top ones, ranked by their Reddit score.
100% Satisfaction Guarantee. Tracking provided on most orders. Buy with Confidence!A brand-new, unused, unopened item in its original packaging, with all original packaging materials included.High seller positive feedback for the seller!Lowest price on amazon!
Android team lead here, I've been working with Android commercially since 2009 (before Android 2.0 was released) and have worked at, or done work for, some big companies (Mozilla, Intel, Google, HTC...). I was in a very similar situation to you in that I was a web development and was bored, I'd been playing with Android in my spare time; I got my first break by volunteering to do an android app at the company I worked for, and went from permanent employee to contractor fairly quickly after that and have been doing it ever since.
First thing to say is that if you can get your currently company to pay you to learn android and stay with them, that's a win win for both parties (you get to learn something new without a drop in salary and don't have to interview and they don't lose a good member of staff).
In terms of moving company, I don't know where you are based, but here in the UK I often see junior Android contract roles coming up for £200-300 a day. Failing that it's just a case of applying for lots of poisitions and really knowing your stuff.
What I would look for in a junior is to have read, understood and put in to practice Clean Code (https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) and Design Patterns (https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124). I would expect you to have a good understanding of basic Java and OOP; a working understanding of MVP or MVVM (https://news.realm.io/news/eric-maxwell-mvc-mvp-and-mvvm-on-android/, https://www.linkedin.com/pulse/understanding-difference-between-mvc-mvp-mvvm-design-rishabh-software); understand threading; know about all the major parts of Android (Services, Broadcast receviers, Activities, Fragments etc); know how to write a custom view; be able to efficiently design a layout in XML and correctly apply styles and themes; understand the support libraries - what they contain, why they exist and what they are used for (and also when you don't need them); understand the difference between unit testing and integration testing and know what makes for a good test; the Gradle build system is a really nice way of defining your project build - knowing the fundamentals is essential.
A few of the main libraries I'd expect you to know and have used would be OkHttp (https://github.com/square/okhttp), Retrofit (https://github.com/square/retrofit), Butterknife (https://jakewharton.github.io/butterknife/), Picasso (https://square.github.io/picasso/) or some other image loading library, GSON (https://github.com/google/gson) or Moshi (https://github.com/square/moshi) or some other json parsing library
If you want to level up then there are loads of advanced topics surrounding Android. Any of these following topics will take a while to learn, but will be worth it and will look good in interviews and on you CV:
There's so much more - this is a large topic and it's easy to feel overwhelmed (I know I did & do) but the sheer amount of stuff to learn, but take it slowly and it'll come. The best way that I found to learn all of this stuff is to have a personal project which I was working on (I started doing an app which teaches you how to play guitar - never released it but learned so much). Get the fundamentals down and them start looking at some of the more advanced things. A good test app would be to write a Reddit client (they have open APIs: https://www.reddit.com/dev/api/) - this will get you up to speed on networking, background services (to poll the API to see if you have any messages) etc
Let me know if this helped or if you want to chat about stuff. Happy to help.
+1, don't just circle jerk and pretend you're above learning patterns before you even understand why they exist. They can be abused, but they exist for good reasons.
I strongly recommend going over Head First Design Patterns to anyone interested.
EDIT: Added links to Amazon just in case anyone wants to see reviews.
[$1 Or More Tier]
Head First Ruby
Head First C
Head First Object-Oriented Analysis and Design
Head First SQL
Head First Statistics
[$8 Or More Tier]
Head First PMP
Head First HMTL and CSS
Head First C#
Head First Agile
[$15 Or More Tier]
Head First Design Patterns
Head First Java
Head First Python
Head First Learn to Code
Head First Android Development
Some book recommendations:
Others that are great and related but not as "necessary" as the above three:
Unrelated to "better code" but still great:
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.
Don't give up just yet, keep looking.
Do you have a portfolio? if not try to work on a project of your own so you can have something to show.
And if you are considering improving your java skills try work with libraries like:
With spare time I would also recommend you to read:
You mention you have a very experienced team around you, this is your best resource. When I started my first coding job, the people around me really helped me become a much better developer. Ask for advice when you are stuck, think about best practices and sit with them and do the code reviews together. If they are writing good code then use their code as a guide for your own. You will soon learn the skills for yourself and realise that it's not as daunting as it seems as long as you can code basic programs. Something you can do to get a better feel for how your basic programs create something larger is to get them to walk you through the architecture.
One thing I did when I started was ask my team leader where I could improve and he recommended me some books. Have a look at head first design patterns, clean coder and growing-object-oriented-software. These are Java based but are applicable to any language.
There are some key concepts you want to get down if you really want to make the most of .NET
Design patterns are used over and over again in OO based systems. A good understanding of what they are for, and how they tend to be used will be helpful when trying to understand key framework extensions and 3d party libraries. I like to point people at Head First Design Patterns. The opinions on design patterns in this book are a bit dated and the examples use Java syntax but they are all relevant to the .NET world and will go a long way to understanding how class names and object structures are used in OO systems.
IMO One of the biggest concepts you'll need to understand in OO currently is the Inversion of Control pattern (also referred to as dependency injection) and the frameworks that provide it. Most modern .NET applications leverage some kind of dependency injection to simplify development and make unit testing and porting of classes easier.
NOTE: I understand many folks in the PHP world feel that PHP is a full OO system. While they have made strides in this area it is not a fully typed OO system. It's a procedural system twisted to provide some OO features.
This is easy, just review MSDN docs and samples. The biggest different you will see in the .NET world is a different opinion in general on casing of object and method names.
This is the part that seems the most overwhelming IMO. The language itself is fairly easy but understanding the huge amount of 1st and 3rd party libraries, frameworks and tools can be daunting. Since you come from the PHP world I am going to assume you are most interested in web based applications. What I would recommend is to pick a set of tools for your web stack and learn them. Once you understand the key pieces of a web application and how they interact you can start picking and choosing different components to meet your needs. I am going to suggest you start with the following stack to get started with a web application, this is the same stack I use for most of my clients making smaller functional websites or simple content driven systems.
Key Concepts for Modern .NET Apps
Some basic tools to help you:
Edit: Now with more links.
First off, well done on getting one of your first apps out there. It's always a daunting step, especially when you're a beginner.
Some general things that will help you improve your current design and any other app you choose to create going forward:
varkeyword where applicable, using string interpolation etc, using auto-implemented properties for your classes, meaningful variable names etc).
Convert.ToDecimal(...), try...catch blocks, you always want to validate user-input as far as humanly possible.
You've already done the first step: admitting that college can only teach the fundamentals while the rest of the things you need to know, you will learn while working.
With that out of the way, here's the next step: apply the Joel Test to your new employer.
If it gets an 11 or 12, you'll be fine. Find a senior developer there to mentor you and you'll be a decent software engineer in 1 - 2 years.
Otherwise, while you might learn a lot of new stuff in your first job, they might be inadequate, outdated, or outright incorrect. In this case, plan an exit strategy ASAP so that you can leave to another company that has a much higher score in the Joel Test. In this fast paced software industry, it makes no sense to spend 5 years in a company where you'd only get to grow the same amount as another guy who just spent 6 months in a better company.
Next step: read. No, not those "Teach yourself [insert language that will be deprecated in 2 years] in 24 hours" books - find the books that teach software engineering, lessons that don't get outdated. Here's the usual suggestions:
Finally, if you have free time, find a local user group or open source community and join them. Not only will you learn fundamentals like version control and automated testing, you'll also be up to date to the latest trends in the industry. Because of this, high school/college students who are active in these communities have a great advantage over their purely academic classmates, not to mention the connections they get in the industry allow them to be employed faster.
Algorithms, Design Patterns, VCS, being familiar with typical CS interviews questions and something that will be really needed
Strictly in order.
Head First Programming
Head First Java
Head First Design Patterns
Head First Software Development
You are welcome!
This is a pretty good book about design patterns.
An alternative to the gang of 4 book which is easier to digest is the head first guide
Head First Design Patterns https://www.amazon.co.uk/dp/0596007124/ref=cm_sw_r_cp_apa_i_jGIzDb57C3ACR
> Look for a book on object oriented programming
For this I recommend both Head First Java and then follow that up with Head First Design Patterns.
Yes, there is also Head First Design Patterns which is also very good.
These are great suggestions. The three books I typically give devs early (that fit in well with the two presented here) are:
Refactoring by Martin Fowler
This is a list of patterns of common refactoring a and how to do them safely. It’ll help you recognize transforms you need to make in your code as it changes.
The Pragmatic Programmer by Dave Thomas and Andy Hunt
This is a great guidebook for how to get better at being a software engineer. Essential read.
And while there are lots of options for design patterns books...
Head First Design Patterns was the one that helped me internalize them. Even if you aren’t writing much (or any) Java, the method of teaching is hugely valuable.
I generally agree, but the problem with patterns is some folks try to shoehorn everything into a pattern sometimes turning something simple into something more complex than it needs to be.
I find that following SOLID with YAGNI at the back of your mind tends to be what seems to work best for me
Along the lines of patterns: I'd recommend Head First Design Patterns
Uhm, I would first start with a complete introduction to OOP. This book:
helped me a lot. Once you go through with it, you should have a pretty solid understanding of OOP and Java.
Also I cannot stress enough how important this thing is, many people seem to neglect it nowadays:
I recommend following books once you understand Java more :):
Effective Java by Joshua Bloch:
Head First - Design Patterns by Eric Freeman:
Clean Code by Robert C. Martin:
Head First Design Patterns: A Brain-Friendly Guide
A relatively unique methodology of approaching design patterns (using Java examples). Understanding design patterns will transform both you and your code.
EDIT: Adding my comment below to my comment here for better visibility and description of the book:
> It can absolutely be read as an introductory book! I would recommend going into the book having a foundation in an OO language, such as Java or C++.
> This was the "textbook" we used in my Object-Oriented Design course; however, the great part about this book is that it reads more as a "narrative" than a traditional textbook. I definitely think this is the best book for learning about design patterns. The GoF book should be used as a reference, after you understand them better.
> All I can say is do not judge a book by its cover, and in this case I mean it literally. I think they are trying to be ironically cool by using stock photos on the cover and within the book. It seems odd to be reading through a "serious" book that look like that, but believe me when I say it will be an eye-opening experience.
Just FYI, Head First Design Patterns is a really fun way to learn design patterns and programming -- each chapter is kind of like reading a comic book where programmers are using a design pattern and Java to build an application.
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:
I really love this book for Java design patterns though, fun to read and really informative:
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.
And you could check stack overflow for question on general programming books. I would always go for a general concept
how 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.
Google "c# github projects for beginners". Theres a whole bunch of interesting stuff out there. You could also download/fork a github repo and try to extend a project, or build on top of it.
I think this repo has been posted here before, but learning design patterns is really useful prior to designing something from ground up. https://github.com/Finickyflame/DesignPatterns
Here's a good beginner's book on design patterns. https://www.amazon.com/dp/0596007124/ref=cm_sw_r_cp_apa_i_FmHsDbGWQ0NTJ
Head First Design Patterns
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.
While you said books haven't helped, give this one a try: http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
This website is pretty good also: http://sourcemaking.com/design_patterns
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.
I'll quibble with the "easy to read" part. As a reference, to look up one individual pattern and learn how to use it, I agree with you. As a cover-to-cover book to learn why patterns are important and how they relate to each other, I prefer Head's Up Design Patterns. I find it much more readable (source: I read it cover to cover, after having had the GoF book on my self for years and only reading bits and pieces).
My suggestion to anyone interested in design patterns is to read the Head's Up book, then have the GoF as a reference.
... none of which helps OP for his upcoming interview. :)
E-commerce is where it's at my man. E-commerce is straight forward. It's a store where you buy stuff. Real simple. However, the backend architecture is a bit more involved. You have to handle things like Databases, Queues, Cacheing, Error Logging, Load balancing, etc. If you want to be a mid-level back end dev you really need to understand the basics of Service-Oriented Architecture (SOA). You should also be familiar with CI/CD Pipelines and docker containers. Try looking into some open source e-commerce platforms:
Also you need a strong understanding of Object Oriented Programming (OOP). So you'll need to understand S.O.L.I.D principles very well. Of the SOLID principles, you should focus heavily on the 'D' which stands for Dependency Inversion.
Lastly, in any decent back-end interview, they'll ask you about design patterns. I'd recommend "Head First Design Patterns" (https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?crid=3JOAGN3VIZZ8P&keywords=head+first+design+patterns&qid=1574177751&sprefix=head+first%2Caps%2C187&sr=8-1 )
Hope that helps!
I have to give a recommendation to http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
It will help if you know the basic catalog of OO design patterns (observer, decorator, factory, etc.). Then, if your "very experienced, knowledgeable leader" is kind enough to name things appropriately, it should be a lot easier to understand what's going on.
Head First Design Patterns has a very fun approach, teaches the basic patterns while also covering core OOP design principles.
So this is what I would consider the "Core" reading list for anyone interested in programming games. None of this is really game specific though. These are just the fundamentals you need in order to be an effective Software Engineer.
C++ syntax: Programming: Principles and Practice Using C++ by Bjarne Stroustrup
Software Engineering: Code Complete by Steve McConnell
C++ gems: Effective C++ by Scott Meyer
Software Teams: The Mythical Man-Month by Frederick P. Brooks Jr.
Why we love Joel: Joel on Software by Joel Spolsky
Problem Solving: The Pragmatic Programmer by Andrew Hunt
Common Code Solutions: Head First Design Patterns by Eric Freeman
Pearls!: Programming Pearls by Jon Bentley
I'll do a supplemental on this in a few days that dives into specific topics related to engine development. All of this is generic enough that it will help you regardless of what you do. You'll notice that very little here is actually language specific. Almost all of this is about the art of making software and process of working with a team. These 8 books alone will make you think about making software in a whole new way.
I find the Head First Design Patterns book to be really helpful. The code samples are in Java, but for the most part the examples are very readable even if you're not familiar with the language. Most of the good stuff is in the explanations, as opposed to the specific implementations shown in the code samples.
It depends on what I'm reading. 20 for the average book is about what I can read. I've had things like What Every Programmer Should Know About Memory that I could only do 5 pages at best and things like Head First Design Patterns where I could do 40 or 50
An interesting side note is that I've also been reading books like Thinking, Fast and Slow that basically say that we have a finite amount of mental will power. We can only focus on a difficult task for so long before we run out of steam. The only way we know to improve focus this is by maintaining decent glucose levels. So you might be able to improve your limit by having a snack or breaking for something to eat.
I've also been reading Seach inside yourself. It's book on meditation written by a programmer at Google. I'm hoping to improve my focus with meditation. It might also let you bump up your number number of pages per-day or at least let you settle in to reading faster
That is a lousy professor. You want to learn more? Nope, don't think so.
You could find open source projects that are written in java. Or maybe check out the source code for OpenJDK (library implementation).
But better yet, pick up a book. You have the popular book Clean Code by R. C. Martin that covers how to write clean and maintainable code. Or maybe the book Head first: Design Patterns by that covers common designs used to make adaptable and reusable code.
But your professor has one point. You should not get lost into code design when still learning the basics. So remember to focus on what you learn in class! :)
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.
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.
If you look in the sidebar, you'll notice a few other subreddits that might be better for this question, like /r/askcomputerscience and /r/cscareerquestions.
I'm learning, like you, and from my experience the answers you'll receive will generally be to learn one language intimately, and to learn data structures and algorithms to the point where you can explain them in an interview and be ready to cobble together an implementation in code (whiteboard or on a computer). Also, design patterns. You'll see recommendations for CLRS and Head First Design Patterns.
Don't forget to check the sidebars and FAQs for each of these subreddits. Your answers are likely to already be there.
It sounds like design patterns might be useful: http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124
Also, like the other commenters have said, you are mainly breaking up your program into smaller subprograms. However, it is really difficult to decide how exactly to break up your program. This is an entirely separate concern from things like algorithms and requires a different type of thinking. Design patterns, if you use them correctly, save time because you don't have to think up a new solution for every problem. They also make it easier for other people to understand your code, force separation of concerns, and make your program more extensible and modular.
The usual advice is "get out and program!" and that works, but it can be very tricky coming up with something to write that's also satisfying. The idea is that you learn best by doing, and that many topics in programming can't really be learned without doing. All that stuff is true and I'm not denying that at all, but some of us need more. We need something juicier than spending hours configuring a UI for a project we couldn't care less about. It shouldn't be an exercise in masochism.
I guess what I'm saying is that there are a lot of ways to learn to write code and books are great if you can really sink your teeth into them (a lot of people can't). Code Complete is a great book on the practice of programming. You also say that you "get" OO pretty well, but it might open your eyes to read up on design patterns (e.g., Head First Design Patterns). You have a long way to go before you really get it
But sometimes programming is about building gumption, so instead of just being practical, try to figure out what you like about computers and keep going deeper into it. If you have an interest in computer science and not in just building apps, then something like Structure and Interpretation of Computer Programs could instill in you an enthusiasm for computers that trickles down to everything else you do. If you're more interested in web design, there are probably similarly interesting books on artistic design principles.
I think what I'm ultimately saying is that you should find what you enjoy doing and just go deeper down the rabbit hole, getting your hands dirty when it's appropriate and interesting.
I'd recommend Head First Design Patterns over the original GoF book because its way less dry.
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
Understanding Professional Software Environments
Mid Level Software Engineer Reading List
Read This First
Software Engineering Skill Sets
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.
I'd recognize that simuduck reference anywhere. it's Head First Design Patterns. We used this book in a class.
For design patterns, this book helped me a lot when I was fresh. https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
Don't be fooled by the cover or the content, it is quirky on purpose to help make you remember it.
When you start building a large piece of software, it's easy to get to the point where you think "Well this is starting to suck. I wish I had started building it like this instead." Those hard-earned lessons are design patterns. If you use the right one, the code you have in the later parts of the project will be easy to scale, easy to adapt to new requirements, and generally painless compared to how it would be without careful planning. Design patterns exist because the same problems tend to pop up repeatedly, so it's worth learning about them (before you need them).
It's difficult to give a general example because design patterns typically serve to solve involved technical problems you don't encounter until deep in a project. However, if you're looking for a good place to start I recommend checking out the Decorator Pattern. It's relatively easy to understand if you're coming from an OOP background. If you really want to learn them, I recommend checking out Head First's book. There are other good sources explaining them, but a lot of them tend to hurt your brain.
For the design elements, I definitely recommond Head First Design Patterns
It's a simple to follow book that does a good job of teaching you the patters and principles of OO design
The Head First series is quite light and fun to read/work through. I'd suggest
Honestly, not too sure if the first book is that great, as I haven't read it, but the look inside view looks quite good and the reviews aren't too bad. Maybe there are alternatives.
The second book I have read and would highly recommend. You need some basic beginner knowledge about objects and stuff first, though.
Edit: Also if you haven't done it yet, think about setting an IDE up for him (or let him do it himself). Nothing discourages more than having to mess with line numbers in compiler output logs, or get frustrated because you run the wrong class files and so on.
Sure! This is a great desire to have.
Clean Code probably most closely deals with you're specific question. It's very readable, and uses Java for the examples. http://www.amazon.com/gp/aw/d/0132350882
But while you're looking for recourses along these lines, you might also take a look at the super thick, bit super good Code Complete: http://www.amazon.com/gp/aw/s/ref=is_s_ss_i_1_7?k=code+complete+2
Lastly, it also sounds like it might be time to start thinking about design patterns - these are ways to implement solutions to common problems in your code using well-established design principles. The "Gang of Four" book is the classic on the topic, but this one offers a more readable introduction I feel: http://www.amazon.com/gp/aw/d/0596007124/
(Sorry for lack of link formatting, I'm on mobile.)
PHP The Right Way is good.
If you want something for SQL I strongly recommend SQL Antipatterns.
If you want something more abstract, Head First Design Patterns is good. It uses Java in its examples but it applies to PHP too.
Read Head First design patterns and really understand what encapsulation means.
OOP won't make sense until you understand design patterns. IMO this is the best book you can find to start learning design patterns. It's for Java but you can apply the ideas on any modern language.
I agree about design patterns. They keep you from re-inventing the wheel. I find Head First Design Patterns easier to approach than the gang of four book.
I would recommend you reading O'Reilly's Head First: Design Patterns It is oriented for Java, but the patterns are the same in most OO languages. I compiled all the examples in C++ and all was great.
The book essentially teaches you how to write code that is easy to modify later on.
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.
Hey there! I personally love patterns. I think there are one of the single best things you can learn as a programmer. So here are some resources I have used and was successful with.
I'd very much agree with this, but not having read any others I can't recommend them. I have heard that Head First Design Patterns is good.
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.
I learned Java in the late 1990s from the first edition of Learning Java and also some of the official online tutorials. I just fooled around with it a short bit. I relearned Java some years later from Head First Design Patterns and Effective Java. The Patterns and Effective books really help you design your classes. Ps: I know nothing about Android programming.
While this is an extremely good book, it is old fashioned and uses examples that are difficult to understand if you are working with modern web technology.
If you are programming Java, Head First Design Patterns is a better choice. It contains the same patterns, but it is much easier to understand.
Unfortunately, there's no real fast-track.
That being said, focus on design patterns and algorithms. Understanding and putting design patterns into use is absolutely your best starting place. Knowing and learning new algorithms gets your brain thinking in the right way about any problem you're trying to solve. These two topics on their own can be really pretty dry and boring, but there's only two ways to learn them. The slow way, by trial and error, by experience (which you've been doing). And the boring way, that's slightly faster, study.
Introduction to algorithms is really good, but dry.
Head First: Design Patterns If you've never used a head first book, they're really well done IMO. Just commit yourself to a chapter a day once a week or something, force yourself through it, and you'll learn tons.
Another pro tip, re-write your existing code. When you realize you should've done something differently, fix it. Any time you find yourself copy pasting code, or thinking to yourself, damn, I should've made an abstract class, or a factory, or ... whatever it is, go through the process. In the end, it always comes down to doing. Learning this stuff only comes from doing.
Have you ever considered reading the SICP book from MIT? You could also try an algorithms book, and brush up on your design patterns.
Sure I really enjoy these podcasts.
As for books , here are some tech books I have read and enjoyed:
There's obviously a ton of other books, but those immediately come to mind.
The book Clean Code will help with improving your code in general.
Head First Design Patterns is great! But in Java. The patterns still apply to Python though.
Here are patterns in Python https://github.com/faif/python-patterns
Agreed. There are plenty of resources out there that will help you understand design patterns. If you're new to the concept, I would recommend Head First: Design Patterns, it might be based on Java, but the examples are simple to understand and can mostly apply to PHP as well. When you feel like you've grasped the basic concepts of design patterns, you can move on to more advanced texts, like Martin Fowler's Patterns of Enterprise Design - this is a great reference for a lot of the more common patterns. There is also Refactoring: Improving the Design of Existing Code. These are great investments that will help you with any project you work on, and will help you if you decide to use a framework like Zend which uses design patterns very heavily.
You are welcome :).
This is one of the best book to learn programming http://www.amazon.com/Structure-Interpretation-Computer-Programs-Engineering/dp/0262510871. It's freely available and the class at MIT which uses this is here http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/
Peter Norvig's advice http://norvig.com/21-days.html
Programming Pearls : http://www.cs.bell-labs.com/cm/cs/pearls/
At https://www.codeeval.com you can solve questions and get interview calls.
You may also want to brush up your design skills as few interviewers might ask those kind of questions. http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124 might be a good place to start.
I think http://www.geeksforgeeks.org is a good place to look for nicely explained solutions and you can find almost all the questions ever asked in a software engineering interview at careercup.com
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&amp;ie=UTF8&amp;qid=1466670651&amp;sr=1-1&amp;keywords=head+first+design+patterns) is a much better introduction to design patterns for most people.
I would highly recommend Head First Design Patterns. If there's actually a bookstore near you you can probably just find a copy there and skim it to get what you need for now.
Design Patterns are typically generic, not specific to any particular language.
So kudos to you for wanting to create more manageable code. I will take a look at your class when I get some time and give you some ideas, but for now I recommend this book that helped me immensely: Head First Design Patterns: A Brain-Friendly Guide. It is a fun read and goes over some of the most important patterns in OOP. I had to read each chapter a few times and practice coding solutions for the knowledge to sink in, but what you will learn is amazing. I was able to apply concepts to one of my games when using for instance the Strategy Pattern to swap out flying behaviors super easy and separate code that will change from code that will not change. I will be posting tutorials on this subject in the future at my new Unity Game Dev site: https://www.theunitygamedev.com
You can take a look at the book on Amazon here: https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
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.
Not specific to Java, but make yourself familiar with Design Patterns. This book is a bit more approachable, the GoF version is a bit dry, but good.
This is usually one of the first things I give to new programmers where I work.
Awesome design patterns book Head First Design Patterns
[Edit] The patterns are expressed in Java
I'm new myself, so I can't offer direct criticism myself, but I thought I'd share the book I'm reading now that I find helpful for learning design patterns.
[Head First Design Patterns]
It seems to me you have set the bar too high. Searching and sorting algorithms alone are one semester course and are programming language independent. You are not tied to Java to learn them, though coding them up in Java will help you come to grips with the language.
If you really want to learn the language, then try to implement the first part of your goal that is stacks, queues, linked lists and binary trees. Do not let the jargon "...data abstraction as applied to elementary ..." come in between. Ask your faculty in helping to write efficient and robust code, that is make your stacks, queues, lists and trees take any sort of data that is use generics they are a big thing in Java. This will help you understand how to make your code be able to serve any type of data.
After you have done the coding of these data structures compare them with the libraries that Java provides for list, stack, queues. This comparison will give you insight as to how to write better code in Java.
Also try to learn a few patterns while coding these things up. For starts you can go to sourcemaking or look up at the book Head First design patterns. You may get lost here or overwhelmed, so do ask your faculty for guidance here as to what you should cherry pick to get the best footing.
Congratulations, and all the best for your job!
Okay, so this is a very popular book for mainly OO design prinicples:
That guy ^ goes over like every design principle you can imagine.
I've also heard that this is great:
Work your way through a book on object oriented programming. This is one of my favorites: Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.com/dp/0596007124/ref=cm_sw_r_cp_apa_i_nGu7Ab5ZBTF2A
It's simple, repetitive, and thorough. It's almost impossible not to learn from it. Some people find it too repetitive, but I think it's great if you don't have much experience with design patterns.
The book Head First Design Patterns really helped me get my head around objects. I'm still nowhere near an expert, but it is a very engaging workbook.
A book I recently read that helped me understand the important and implementation of design patterns was [Head First: Design Pattern](Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.ca/dp/0596007124/ref=cm_sw_r_cp_apa_i_3hEdBbDFGPCP6) . The book introduces the concept in an informal way and makes the learning experience fun and worth it.
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).
In my experience, languages are pretty easy to pick up once you know one. I think you'd be better off sticking with Java and exploring concepts, algorithms, data structures and certain frameworks.
When I was starting I got a lot out of the GoF Book. It's a C++ book but they don't really use any C++ features that are hard to translate to Java. I've heard good things about Head First Design Patterns too but haven't read it.
As far as Java goes Spring and Hibernate are two great libraries to be familiar with, since you'll encounter them in the wild pretty regularly.
If I were to suggest something you might not have learned, consider installing VirtualBox and using it to run Ubuntu. Familiarity with Linux will give you a big leg up and Ubuntu is a pretty good way to ease into it. Plus it has packages for a ton of different programming languages so you can experiment with any that catch your fancy.
I enjoyed http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124 though it's not language-centric if you're looking for that.
I'll tell you my approach. I use c# to make windows applications used internally at a college that usually display student and loan information. I use a couple patterns (unit of work / repository and mvp.)
I break my project down to multiple layers (data, domain, service, presentation, and view).
My domain layer simply holds poco classes. That's plain old clr objects (classes with only public properties). Each class represents a table in my database and each classes' properties represent a field in that table. This layer also holds my validation classes.
The data layer is used to interface with my database. I use Entity Framework as my ORM and wire everything up using generic repositories and a unit of work.
My service layer is the middle man between my data layer and the rest of the application. It defines and implements what I can do against my database. For example: StudentService.GetAllActiveStudents() or CampusService.GetTeachersByProgram() etc...
My presentation layer is, well, the 'P' in MVP. And my view layer is the 'V'. Look up mvp pattern if you're interested.
The beauty of doing it this way is that everything is loosely coupled from everything else. I can switch out my data source and only have to change code in my data layer. I can write a new user interface that implements the view interfaces defined in my presentation layer and i know it will work. I can allow another application to use my service layer (create an api) for reuse. And the real beauty is that everything is testable. I follow test driven development pretty hardcore and doing it this way allows me to unit test everything.
I don't want to go to into detail about what each of these layers do because that information is easily found from google but the point is is that there are patterns out there which define how you design your project, how you break up your project into layers, and what those layers are responsible for. You might want to check out the book Head First Design Patterns. It uses java examples and it's really good at putting patterns into perspective.
If you want to know some algorithms that are handy when designing systems to work together, read Head First Design Patterns. It's a pretty light read but if you do most of their exercises, it sticks pretty fast.
Just break down the problem into smaller and smaller chunks. Come up with a few systems, a map system where the grid is stored(i.e. 14,17 is a barracks and belongs to room id #115.(also, make it a singleton so that the building system can ask it wheres free)) and then the room system(pretty much just manages a collection of the rooms built) which keeps track of all the rooms and updating them every tick, and then have a Collection system that is a listener to all the rooms and will pop up showing that they need to be collected, then have the unit system where all the characters are stored, and probably a movement system to track which characters are moving where, and more systems as you build it bigger. Then a game StateMachine(which would probably be the dominant system and passes updates to all the other systems) to keep track of what to menus to be showing the player, and when to take input to the map or whatnot.
If something doesn't feel good to work with, refactor it and try to think of a simpler way to use it. It's a big task, and you shouldn't try to fit the whole thing in your head at once.
While Design Patterns is the original book, I feel most people are better suited to getting books that were published later that make the first Design Patterns more digestable. DP is a good reference to have on the bookshelf for any software developer but I feel if you're new to Design Patterns:
A. There are better free online sources for the raw Design Patterns in the GoF book like this website
B. There are better books out there for explaining Design Patterns in the GoF book to newbies like Head First Design Patterns
Upvotes for Head First Design Patterns, it's a great reference and fun read!
>I want to make more applications...but I don't have any ideas..is there any reading you would recommend me to do?
Have you read Head First Java?
Head First Design Patterns?
The pragmatic programmer?
>I want to be employable...after 3 years doing a computer science course, I feel like I still only know the basics. What Java books do you value most and feel helped you become a much better programmer?
In my particular case, I didn't read books. My interest has been developing web applications, so I have gotten more information from frameworks' documentation an tutorials than from books.
>What are some examples of programs you made when you were 1 or 2 years into your Java programming career?
Hmm... I created some plugins to check on the availability of some servers and services. When it detected those were unavailable, it sent email and SMS alerts to our system administrators. Things got interesting when the email server was down tho.
>What resources would you recommend me reading to understand how to make my android applications able to access the internet..so that users can compare high scores and achievements?
>I have the drive. I love programming and I want to be a successful one. What advice can you give me?
Code as much as you can. Check what kind of applications you want to develop and find which frameworks can help you build them. You don't need to re invent the wheel (unless necessary). Follow the developer's guide and check if there are any tutorials that you can use to improve your knowledge and make better applications in the better way possible.
>Thank you for your help. I really appreciate it. I've felt stuck for days and i honestly did browse a lot before I came here. I've seen a lot of Java developer jobs paying £20-40k but i feel i don't have the relevant experience to even apply to them yet. I feel like i know very little..I.e I have no idea what J2EE is and what it's used for.
"Java Platform, Enterprise Edition or Java EE is Oracle's enterprise Java computing platform. The platform provides an API and runtime environment for developing and running enterprise software, including network and web services, and other large-scale, multi-tiered, scalable, reliable, and secure network applications. Java EE extends the Java Platform, Standard Edition (Java SE), providing an API for object-relational mapping, distributed and multi-tier architectures, and web services. The platform incorporates a design based largely on modular components running on an application server. Software for Java EE is primarily developed in the Java programming language and uses XML for configuration."
If you want to build enterprise web-enabled applications, this is what you should start reading:
J2EE 6 Tutorial
And I always recommend these as well, they helped me a lot when I was learning Java Server Faces:
http://www.mkyong.com/ (He has an Android tutorial that might help with with your interest to develop applications for that OS)
True, well in case anyone would like to learn more about design patterns, this book is awesomely corny and easy to read. Doesn't matter if you don't know java at all.
And read this before you start the book as it's probably the most important point they kind of just ignore.
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.
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 :)
> ...and then rewrite the whole thing to learn why composition is better than inheritance
'Extends' is evil, and should be used as a delicate seasoning in your design, not the key ingredient.
If you don't know why we say this, start here:
Head First Design Patterns
I graduated and started working this summer. One of the senior programmers handed me this book. Head First Design Patterns
In terms of practical, professional skills, here are a few I would recommend:
For more tailored recommendations, where do you feel that you're weak? There are plenty of college textbooks that can introduce you to algorithms, but if you have an end-goal in mind, you can really focus your learning. Work on some tougher projects than you're used to, and study open source code that does interesting things.
You are on the right track. The most important to understand is the fundamentals of any programming language. You mentioned Java. Java is an object-oriented programming language. In order to write good code in Java, you will need to learn what is an object? What is object-oriented? Like, what is inheritance, polymorphism, classes, interfaces etc etc. Once you learn the concept of OOP and you want to learn Python (another OOP language), it will be that much faster, because you already understand the concepts. Python has its nuances but you learn as you go along. I think you should start with the Head First series by Oreilly. They are sooo good at teaching this sort of stuff. I will give u the links below:
Head First Java
Head First Object-oriented Analysis and Design
Head First Design Patterns
Buy just the one book and start from there. Checkout the Head First series, you may like other books too. Also, google 'design patterns' and read about it. Some people mention Algorithms and that is all great stuff and you will learn as you write good code. There is another book I would recommend:
I would also suggest that you should try different types of programming languages as well. Like functional (LISP or Scheme) or procedural (C). When you do that you will start to think differently and it will expand your knowledge. LISP was created in 1958 by John McCarthy. My friend works at Google and he told me that they are using LISP behind Google Maps.
A lot of people are fans of Code Complete. I tried reading it after being in industry for a decade, and I found it to be very dry and boring. The general consensus from people that I've talked to is that it's more useful when you're just starting out. Maybe I just came to it too late.
A better book (in my opinion) in that same vein is Clean Code. Clean code is shorter, more focused, and has better real-world examples. It feels less "complete" (hue hue) than Code Complete, but to me, that's a strength. As a quick point of comparison: Code Complete devotes 32 pages to the chapter on identifier naming; Clean Code devotes just 14.
I got a lot out of Design Patterns. I seem to recall that the pattern fad was in full swing back when I read this in 2005-ish. I think I had independently discovered some of the patterns already at that point, but this book helped me to codify those ideas and also showed me some new ones. Some of these patterns are now seen as antipatterns (I'm looking at you, Singleton!), and all of the patterns have an object-oriented bias. But there's still something useful in the pattern language, and this book is a reasonably comprehensive start. The book is somewhat dry, and some people report that Head First Design Patterns is a gentler and friendlier introduction. Head First Design Patterns hits the essential patterns, but misses a lot of the less popular ones.
Eventually, you'll need to work in a codebase with some technical debt. Maybe it's debt that somebody else put there, or maybe it's debt that you introduced. Working Effectively with Legacy Code is still my go-to recommendation. It defines technical debt as code that is not under test, it introduces the idea of "seams" that you can use to pry apart code that's too tightly coupled, and it then provides a cookbook of specific scenarios and reasonable approaches.
If you're looking for thought-provoking videos, I recommend anything by Rich Hickey. I don't know if I've watched all of those, but I remember good things about Hammock Driven Development and especially Simple Made Easy.
Get comfortable with a source control system. I didn't use source control in college, since it wasn't needed for any classes, and that was a missed opportunity. The whole world loves Git, so you'll probably want to learn it if you haven't already. But I'll also toss out a recommendation for Mercurial. I haven't used it in years, but I remember finding it to be quite good.
If you are looking toward application development(games or otherwise) I'd suggest looking at more practical beginning programming books, don't even worry too much about making a game yet or building complex algorithms. I've found the Head First series fairly good in the past, so maybe try out https://www.amazon.com/Head-First-Java-Kathy-Sierra/dp/0596009208
Once you get your head around basic application development a bit more, I would highly suggest learning design patterns and can fully recommend the Head First book on that topic.
You can follow that up with the Game specific book on patterns, https://www.amazon.com/Game-Programming-Patterns-Robert-Nystrom/dp/0990582906
With all of that you should have enough to start asking more pointed questions and being able to Google up useful answers and tutorials that will get you on the road to building games.
Edit: That said, if you are looking at doing to extensive AI programming, specializing in engine design or other systems type development, start looking for books on the topic that interests you most. It's pretty easy to Google up book lists on these kinds of topics, and from there you can cross reference recommendations and should be able pick out ones that will help you get started.
^ start there
DAOs & factory are design patterns. Old book but good: http://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124
Caching + retrofit
This example is dated. I'm using okhttp 2.0 + retrofit 1.6.1 so it doesn't quite look like this, as the example uses older libraries, but is similar.
I'd share code but I signed documents stating I wouldn't do that, and I like paychecks :P
I think the Head First Design Patterns book is actually pretty good. Some might knock it due to its silly and childish nature, but that's part of the reason why I like it.
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++
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.
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 :)
For OOP Design Patterns also check out:
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):
One thing that's awesome about Python is the language itself helps solve a ton of the gang of four's design patterns. That said, I really appreciated reading Head First Design Patterns because it helped me understand what I already did intuitively better https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/ref=sr_1_1?ie=UTF8&qid=1540609515&sr=8-1&keywords=head+first+design+patterns&dpID=61ZG-hATOeL&preST=_SX218_BO1,204,203,200_QL40_&dpSrc=srch.
> Have a lot to learn about OO
Read Head First Design Patterns. It is written in a style that is super-corny but actually sticks in your head really well. Also, the syntax it uses is java, but you don't need to know how to write Java.
Learn how to write Automated tests. They will help keep you from spending late nights hunting down bugs. Test-Driven Development with Python is excellent and free.
Also, learn to use assertions and pdb to find bugs.
Learn how to set up your development environment and servers. I recently wrote a tutorial on this and would be grateful if you would check it out and give me feedback: https://amfarrell.com/saltstack-from-scratch/
First of all, applause for the great start.
Here are some criticisms/suggestions I would like to offer. Keep in mind, I am not assuming your level/experience as a software developer:
> I force myself to write raw SQL Request to get better with SQL
while that is commendable, it is not really a good idea to write raw sqls in production code if there are ORM library alternatives available. Remember, it's not always you that is going to read/modify the code. While ORM syntax will be fairly universal, your style of writing SQL may vary starkly from other people - which is what creates confusion and lets errors sneak in. Even if you want to do that, maybe keep the raw sql in separate modules (point 2).
Finally, remember that all these are just suggestions, and you may already know them. You will decide which ones to take and which ones to leave behind based on your situation.
Again, great job (I also learnt something from this). Just make sure you keep running.
I just chose some books that looked good from this list and this one.
The one's I got:
Cracking the Coding Interview
Don't Make Me Think
Code (currently reading)
Regular Expressions Cookbook
Head First Design Patterns
Working Effectively with Legacy Code
Elements of Programming Interviews in Java
The Mythical Man-Month
The Design of Everyday Things
I figure that's enough reading material to last me until I graduate.
>How valuable is an Oracle cert?
No more than any other online course from a respected institution such as google, say: https://cloud.google.com/training/free-labs/ or one of the online courses available at MIT/Stanford.
>What else should I look into to boost my repertoire?
See if your university has any business partnerships you could do a 2-3 month project for. I worked with one of the university's here in the UK as part of a business/university partnership and that gives the students real world experience and us some free work. Win-win if the project is completed.
Sorry - mostly UK (amazon) links :)
TDD - https://www.amazon.co.uk/Growing-Object-Oriented-Software-Guided-Signature/dp/0321503627/ref=sr_1_1, Video by Trisha Gee whos fairly well known for speaking on this stuff: https://www.youtube.com/watch?v=QDFI19lj4OM (some very handy shortcut keys in the video and a good outline of some of the tools available to you).
Clean Code - https://www.amazon.co.uk/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882 (by "Uncle Bob")
Design patterns - https://www.amazon.co.uk/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1
Learn to use shortcuts in Intelli J to speed up your ability to generate/refactor code: https://www.amazon.co.uk/Getting-started-IntelliJ-Hudson-Assumpção/dp/1849699615/ref=sr_1_1
Also Jetbrains does good newsletters (curated by the same lady that made the video above under TDD) sign up to stay up to date with interesting/relevant blogs/articles/industry news https://www.jetbrains.com/resources/newsletters/
Github - https://www.amazon.co.uk/Version-Control-Git-collaborative-development/dp/1449316387/ref=sr_1_4
Bash Commands - https://nikgrozev.com/2016/05/22/shell-cheatsheet-part-1-common-bash-scripting-tmux/
XP/Scrum/Kanban development process - https://www.agilealliance.org/glossary/xp/ the way we work
Trusted developer blog on various engineering topics https://martinfowler.com/
Interview Prep https://www.hiredintech.com/courses
Hint: the above books are likely to be available at any academic library. If not, request them. you likely only need to read 33-50% of them and you'll be golden. I imagine you can likely get hold of electronic versions of these books as well.
The best thing you can do to prepare yourself is to start practising developing projects... get them up on github. it could be a website, a desktop application/game/tool, a demo of sorting algorithms, a web service... literally anything. Fork others' projects, code a feature request and create a pull request back to the original repository/codebase on github. Just build something rather than nothing. Anyone can do the latter. There's so much more opportunity now that we have github available. Think of any thing you might be interested in working on and someone, somewhere has likely already got a project underway in that area, and you're free to submit a pull request to their repository at the click of a button. This wasn't really possible 10-15 yrs ago.
The simple answer is there's so much to know, you just have to find what your interests/passions are and follow those as much as possible.
No matter how good you are at what you do today, the tools will be different tomorrow and may even depend on the industry you enter: AI, web services, blockchain, computer vision, robotics? The list is long and each one requires you to be highly trained (over many years) before you're considered any good at it.
Just try to learn what you can. Find something that genuinely interests you and study it until you become a trusted authority on the subject, or you find something you're more interested in instead.
If you have any ideas for the type of area you might be interested in put them up here and perhaps someone can point you to a relevant project?
https://en.wikiquote.org/wiki/Howard_H._Aiken "Don't worry about people stealing your ideas. If your ideas are any good, you'll have to ram them down people's throats."
I've found that I gained most of my best experience on the job, and that staying at a job where I wasn't learning anything was a huge mistake and detriment to my career.
That said... I don't think I'm a super genius either. I did well in college and my GPA helped with my first few jobs. But I have lots of hobbies outside of work, and rarely spend my time at home thinking about the office. A lot of times companies aren't looking for the super genius type either... if they were they'd have a hard time filling staffing requirements. I think the keys are learning how to interview well, focusing on letting the interviewer know that you're willing and good at learning and having the basics of OOO down to a T. Come off as confident, even if you don't feel it. It never hurts.
As far as books go, here are some of my favorites:
Programming Interviews Exposed
I'm mostly a java programmer, so here are three absolutely necessary java books:
Head First Design Patterns
Core Java 1
Core Java 2 - Advanced
I'll let you know once I figure that out.
The biggest problem is that as cool as design patterns are, real world problems rarely, if ever, fit directly into the mold of a design pattern. Sometimes you need to combine multiple patterns. Sometimes you need to majorly tweak the pattern to make it fit your problem. Then there's question of, are you over-engineering your solution?
All hard questions to answer. The best way to know is... experience. Have real world experience of trying these things out. So to answer your question, the best way to learn how to use design patterns effectively is to use them on real world problems. Not a satisfactory answer by any means, but for some things in life, there are no shortcuts.
It's like answering, "How do you get good at public speaking?" The answer is to speak in public. There's no book you can peruse, there's no youtube video you can watch. You just have to do it again and again and again.
That being said, reading about design patterns is step 1. Everyone knows GoF. It's a really dry read. Personally, I own Head First Design Patterns. Very easy to read. I haven't bought the design pattern resource you listed, but I did read the freely available ones. Personally I think it's too simplified. Again, I highly recommend Head First Design Patterns. I wish there was Head First everything.
This is a really good and easy to read book about design patterns.
Gives you a good idea about basic concepts.
The Stanford Algorithm book is complete overkill in my opinion do NOT read that book. That's insane. Read it when you've been doing programming for a while and have a grasp of how it even applies.
Here's my list, it's a "wanna be a decent junior" list:
Reasoning: So, the first book is to give you a sense of all that's out there. It's short and sweet and primes you for what's ahead. It helps you understand most of the basic industry buzz words and whatnot. It answers a lot of unknown unknowns for a newbie.
Next is just a list languages off the top of my head. But you can pick anything, seriously it's not a big deal. I did put Java first because that's the most popular and you'll like find a mountain of resources.
Then after some focused practice, I suggest grabbing some SQL. You don't need to be an expert but you gotta know about DBs to some degree.
Then I put an analysis book that's OOP focused. The nifty thing about that book, is it breaks into design patterns nicely with some very simple design patters to introduce you to design patterns and GRASP.
Then I put in a legit Design Patterns book that explains and explores design patterns and principles associated with many of them.
Now that you know how code is structured, you're ready for a conversation about Architecture. Clean architecture is a simple primer on the topic. Nothing too crazy, just preps you for the idea of architecture and dealing with it.
Finally, refactoring is great for working devs. Often your early work will be focused on working with legacy code. Then knowing how to deal with those problems can be helpful.
FINAL NOTE: Read the soft skills books first.
The reason for reading the soft skills books first is it helps develop a mental framework for learning all the stuff.
Good luck! I get this isn't strictly computer science and it's likely focused more toward Software Development. But I hope it helps. If it doesn't. My apologies.
I strongly suggest picking up the book Head First Design Patterns. The examples are in Java (but simple enough to do with no Java experience) and easily adaptable to PHP. It teaches best practices, design patterns, and coding principles and explains why they're good.
Once you start thinking and coding in design patterns you will be able to learn Unit Testing. After you know how to write Unit Tests you can then write code by TDD (Test Driven Development).
Edit: It's also imperative you know about PSR-0. It allows PHP to easily implement the SR (Single Responsibility) principal.
Okay. Watch the official tutorials for sure, and I recommend looking at the tutorials posted on the /r/Unity3D sidebar fore more.
If you haven't already, learn some design patterns! Head First Design Patterns was an amazing resource for me. You'll learn how to organize code in ways that actually makes it readable extendable in the future.
Read /u/RankWeis's write-up for what a framework is, he gave a very good explanation.
I would personally suggest advancing by learning basic / common design patterns. Spring is a dependency injection framework at its core, and dependency injection is a design pattern you should know well before picking up Spring to really understand and use its full potential. It's one thing to pick up and use a framework, quite another to know why you're using that framework and what problems it's there to solve. I would also argue that design patterns are something you can take on any project, not limited by the chosen framework, so you would get more mileage out of knowing those before jumping into a specific framework.
I would highly recommend the Head First Design Patterns book. It's very well written and makes the common patterns very easy to digest. http://www.amazon.com/First-Design-Patterns-Elisabeth-Freeman/dp/0596007124
The best book I ever read about Design Patterns is, no doubt, "Heads First Design Patterns" https://smile.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124/ref=sr_1_1?s=books&amp;ie=UTF8&amp;qid=1466476241&amp;sr=1-1&amp;keywords=heads+first+design+patterns
Head First Design patterns
Head First Design Patterns (2004) (homepage | amazon) was comparatively friendly and well regarded.
This class on udemy is great, it covers absolutely everything about angular. https://www.udemy.com/the-complete-guide-to-angular-2/
Other than that if you want a strong understanding of the fundamentals you should invest some time in studying Object Oriented Programming and design patterns built on OOP. For instance angular uses the Decorator and the Observable patterns heavily. A good book on this is Head First Design Patterns, though it uses java code it may still help. It has a lot of pictures and psuedo code puzzles
Just think of these design patterns as mental tools, along with a little bit of coding syntax, that will help you elegantly handle more complex problems in your code. Using TypeScript lets you put all of the tools in that book to use.
Headfirst Design Patterns (pardon the ugly cover), this book easily illustrates and explains software engineering patterns that many would consider essential to writing good software. I'm currently in my senior year of Computer Engineering with a Software Emphasis and patterns are very important for writing manageable, maintainable, and readable software. (apologies for ugly link)
Something else I recommend is buying a raspberry pi and setting up a basic home web server, you can Google easily how to so this. This is a fantastic introduction to full stack development and the possibilities are endless.
Hope this helps, good luck!
Edit : I also work as a software developer and will be working there full time when I graduate.
Oh god where to begin?
Well I Like to think there are level of programming understanding that are relatively tiered.
Tier 1 - How to Code
This one is tough as there is no real definitive best answer. My personal primer of choice is
> Fyi - , that is not "in one day" that is , in 24, 1 hour sessions equating to a hypothetical 4 college lectures a week lasting a month and a half of intensive training. A huge amount of homework is required to accompany that primer.
so now you can write an app, what next? well. to finish the thought:
Tier 2 - How to Code...
so other programmers don't want to hit you over the head for each line in your longest function screaming CYCLOMATIC COMPLEXITYYYY
Here we talk about how to program properly* You want to be looking up Uncle Bob . Head over to
and check out his video form of his famous book:
Now you should be writing code that doesn't make other programmers eyes bleed.
Tier 3 - How to Code..To Solve Problems
Here we talk about design patterns. Now, you will bump into a lot of debate over their value but...that is stupid. that is like some people saying all carpentry should be done with a saw and another group saying carpenters should never use a saw. Design patterns are names for recognised ways to solve problems you will hit every day in your programming. They may not always work in your case but at worst they will have you thinking around a problem better.
For a primer, check out:
In fact the entire head first series is great, It is like the For dummies series for programming principles. Great for morons like myself.
With that read, get the real design pattern book:
Don't expect to actual understand almost any of this. I read that book cover to cover and it didn't actual click for me till it slapped me in the face when i was in the real world developing business tier applications. Although having read it so many times meant I new which pages to flip to when I was ready.
Tier 4 - How to Code... For Users
This is a whole different kettle of fish. Now you may have written the perfect app to do X with only two buttons, you will find quickly that users are adept at licking the buttons in just the correct order to cause your application to explode. You need to program applications so the cast of jersey shore can use it.
I am a fan of the blog:
Joel (Co-founder of Trello) covers a lot regarding front facing applications and UX that is required reading...even if he a bit cavalier on his approach to testing.
This is the next part. Testing. You are going to want to Learn about Defensive Programming andTesting. There is a wealth of tutorials over on pluralsight for these.
Tier 5 - When NOT to Code
This is a hard step to get to. Realising that copy and pasting code is GREAT!..but for the right reasons. Once you jump over the initial Copy+paste = the greatest thing in the world barrier , most developers grow a level of defiance that borders on the absurd. Preferring to rewrite the wheel instead of using ...the wheel. When you can honestly say you could* program it from scratch, it is perfectly okay to use libraries and apis.
This is where I go to:
and hit up Sacha and others. They show you fairly feature complete and interesting implementations of problems, not just the one or two lines you get from Stack Overflow. Granted this is miles more complicated but it shows not only how to do it, but how to do it right and WHY to do it right. and github of course.
Tier 6 - Learning From Mistakes
Now that you have climbed code mountain and are absorbing the combined knowledge of all the internet geniuses, it is time to see where you went wrong.
Head over to
and post you functional applications. There a number of people will politely tell you not...how but how to do it better, general improvements in design, logic and reusability. take you through the solid principles and much more. Also..say hello to me if you like :P.
You don't even have to learn exclusively from your own mistakes.
and cringe at some examples of real software....and if you don't understand why you should be cringing..learn.
Tier 7 - How to think like a programmer
Now things get a little bit meta. The best way to become a great programmer? don't JUST read programming. Read books like:
Read anything and everything, exercise your mind. books on architecture, books on carpentry. any kind of design and problem solving with stretch your understanding of how to climb those brick walls you will hit.
Read some of the more general programming blogs, like:
Read anything and everything.
I would also say as a personal suggestion, although i left it out of the mandatories up above as it is a bit controversial, I suggest going TDD. Test driven development. It is not for everyone, a hard ethos to get into but in the real world, in business applicable coding...a life saver. Uncle bob is the man for that again.
Finally I am a fan of Rubber Ducking. Great way to work though problems.
If you want some final reading, I left them out because everyone and their brother has these (and most of the above) in their top 50 programming book lists so it is a mite redundant:
The basic ideas you're looking for are 'design patterns'. If you've ever browsed through code and saw class names like FooFactory or BarPublisher or QuuxVisitor, you've seen design patterns in action.
The 'canonical' book on design patterns is often referred to as the Gang of Four book.
But, it's fairly dense. I recommend the this one instead, it's a more efficient read.
my path from pre-oop to feeling like I finally understand why to use OOP principles and when / how to implement them has been:
cakephp (briefly) > yii > laravel > Symfony 2 > starting now on ZF2
shortly after getting serious with learning MVC for work reasons, I started by trying to use a framework. I experimented with various - and only really got a basic grasp of why after trying yii properly for a project.
I then redid the project in laravel - improving it but it was still a complete shambles really.
Then I got the headfirst design patterns book:
I cannot recommend that enough.
It's in java but you should be able to grasp it - the main thing is the way constructors are named after the class name in java threw me at first, but after that, its very similar indeed.
Don't pirate that book either - I have tried it in pdf and I bought it in the end, as its not a very easy book to read if you dont have it on paper.
From there, I read about half that book and was able to apply what I had learned to how these MVC frameworks were working - and that was without ever touching the MVC chapter.
Learn about why / how to abstract, factories, why programming to interfaces is super important, and a ton of other things that will take you from being somewhere around beginner / intermediate, to comfortably intermediate heading towards advanced.
Just go for the "Head First Design Patterns" (the gang of of four one is good but very arid and I would not recommend it as a first book). The "Head First" series is very user friendly.
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.
Just to piggyback on OP's question (because I'm interested in the same thing), does anyone have any opinion on Head First Design Patterns?
I was looking at that before I saw this thread.
I misunderstood. However, I'm not seeing how that has any bearing on this conversation. Your original point was that building a well-thought-out project using proper design patterns takes longer than otherwise. Yes, I have experience and so yes it might be easier for me, personally, but what does that have to do with your original point? Are you saying that the initial time investment somehow nullifies the benefits that I am arguing for? You learned how to write code in the first place. Why not learn how to make your applications more maintainable?
If we are including the initial time investment in understanding how and when to use design patterns, then yes, there is a decent chunk of time to be spent. For me, it took about 6 months spent reading this book, using Symfony, and making myself sick with google searches to really feel comfortable-- and I am still always learning new things. But that investment has proven immensely beneficial for every single project that I've worked on since.
None. I'd still be going for looks on the beach. Don't read a programming book. Read a theory book, like Head first design patterns (it's got a cute chick on the front).
Many of the "why" questions are more general than just Java. I'd suggest a book on design patterns ([Head First Design Patterns](Head First Design Patterns: A Brain-Friendly Guide https://www.amazon.com/dp/0596007124/) is pretty good and accessible for a beginner) or object oriented programming in general.
Learning the theory and patterns of polymorphism, composition, etc will certainly help when trying to understand why languages implement certain features, and will also make you much more capable of using those features in the wild.
Head First Design Patterns is a great place to start.
Head First Design Patterns
Like anything else it's a tool and should be used at your discretion. Design patterns have their own pros and cons. But the book will at the very least give you some useful building blocks for organizing your code.
It goes through the why as well as the how.
> Like a bunch of spaghetti
That might not all be your fault, I have no idea how good the codebase is! ;)
Two resource recommendations for you:
One other thing I encourage you to do is to ask questions of the senior devs on the team. Try to find someone who you get along with and might be able to serve as an informal mentor. I know it is difficult to say "I don't know", but it is a lot better than floundering with a problem for a week. Good luck!
See these resources
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.
>So what did you do? Anyone else have a formal CS education and feel like they came out of it with nothing?
I graduated in 2006 and I've been doing web development professionally for almost four years now. Until about two weeks ago, I felt like I could have skipped my entire five years at school because most of the stuff just doesn't apply to web development since it's so far abstracted from the hardware. I was reading my algorithms book on the toilet the other day when I realized that I learned a shitton at school and it gave me an incredible advantage over the guy who learned web development on the fly. It helps to go back and re-read things after you have a context to put it into so you can apply what the theory to what you've learned.
It took me a long time to start getting designs down. You have to make a lot of mistakes before you can learn from them. It's as simple as that. Don't get discouraged. If you haven't read Head First Design Patterns, buy that book right now and read it cover to cover. I had read design pattern catalogs, but none of them conveyed the 'why' as well as HFDP did. They don't have abstract, car has wheels, Ford is a car. They have real code examples and they show you why you should favor composition rather than inheritance. Why you should follow the law of Demeter.
I've entertained the notion of starting over several times. Don't quit, and don't get discouraged. If you ever get to the point where you think you've learned all you need to learn and you're writing code that can't be improved, start over.
Judging by that image, I think it's a page from Head First Design Patterns, which really is an excellent book on the subject, it is so easy to read and provides very clear examples for everything
You can just google for it to find a PDF version
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:
I would read them in that specific order.
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.
Head First Design Patterns is what I've used. It takes the very dry and detailed approach of the GoF book others have mentioned and makes it much more approachable and human friendly. They have a whole section at the beginning about their teaching approach in the book. There's a lot of examples, diagrams, conversations between participants. They take a conversational tone which is much easier to understand and read. As a student I cite the GoF but I learn from the Head First book.
If you are also new to OO programming in general, I would get these books and work on the examples. They will provide you with an excellent foundation for programming in Java.
> Because I did not know how to instantiate objects the only way I knew hot to get a variable from another class was to make it static.
Oh aahahah. Sorry, was being stupid. ANd my OOP isnt too great, is this the book?
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.
Came here, all excited to mention the Pragmatic Programmer but it's already at the top of the list. My upvote can't even help it get higher.
Then I came for the Mythical Man-Month, but you got me there too.
FinalSin, you're killing me here :)
That said, there is one more on my list that isn't covered here:
Head First Design Patterns taught me more about software design than any other book ever, arguably comparing to Pragmatic Programmer.
If you want to understand why objects and interfaces are useful, I'd recommend reading Head First Design Patterns. It is truly the first resource I came across that made me grasp why objects and interfaces have a useful purpose.
I started to write an example for ELI5, but I decided that the first two chapters of that book would be a great example. It even includes ducks. :P
this book was a good starting point for me. https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124
Head first design patterns
This might also help
This is a pretty nice one for picking up design patterns:
then yes, you are writing bad code. Good instincts!
read this ... a few times.