Reddit reviews Head First Object-Oriented Analysis and Design

Sure :)
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 Javascript Programming
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

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:

• Learn about SOLID programming principles. I won't go into too much detail because there is a wealth of resources out there to explain the basics better than I ever could such as this. Once you understand what each of the letters in the acronym means, you can use it as a framework to assess your own design.
  
• Design patterns can also be a valuable tool for a developer (though use with caution, if not used properly they can make your application needlessly complex). This site has some simple examples available specific to C#, but you might want to check out some material on object-oriented design first to get a better understanding of WHY we use patterns in the first place. The Head First series is quite a beginner friendly option in this regard Book 1 Book 2.
  
• Take a look through the official Microsoft C# guidelines, I noticed a few instances where you could improve the readability of the code based on their checklist (using implicitly typed variables with the var keyword where applicable, using string interpolation etc, using auto-implemented properties for your classes, meaningful variable names etc).
  
• Look up DRY (Don't repeat yourself), and KISS (Keep it simple, stupid), it will help you write shorter, clearer methods. I can see a few places in your code where you could decompose certain operations into separate methods.
  
• Treat user-input as an unpredictable spawn of Satan that it is: using decimal.TryParse(...) instead of Convert.ToDecimal(...), try...catch blocks, you always want to validate user-input as far as humanly possible.
  
• BONUS TIP (though some may disagree with me here): try ReSharper out, it will give you valuable suggestions while coding that you can otherwise miss. Even after 8 years of experience with C#, it helps me out tremendously.

I think you're talking mainly about scope.

Analogy time. Let's say you have an object. A smartphone.

Your smartphone allows you to interact with it, but your interactions with the phone are limited to touching the screen, tapping icons, that sort of thing.

When you tap an icon, all sorts of things happen in the phone. From the higher-level stuff (load application, connect to internet, etc) to the lower level stuff (electronics, battery, storage read/write, etc.). You don't care about and shouldn't really have to know anything about (or have access to) that stuff. All you need is an icon to tap. A button to push.

Simple example time. The same idea applies to classes/methods/etc. within your code. You may have a class that connects to the database to retrieve a list of products for you. When you have other code using that class, all that code needs access to is your "GetProducts" method. The code using this class doesn't need to be able to establish the database connection, form the query you need, execute it, adapt the data and move it into a list -- it just says "gimme some products".

public class ProductRetriever {
private DbContext _myDatabase; // <-- Code using this class doesn't need to know about your database connections.

private void connectToDatabase() {
// DB Connection stuff goes here.
_myDatabase = new DbContext();
}
private List<Product> RunQuery() {
// DB Query stuff goes here.
_myDatabase.Database.SqlQuery<Product>("select * from products").ToList();
}
public List<Product> GetProducts() {

connectToDatabase();
return RunQuery();

}
}

In this simple example, any code that uses this class...

ProductRetriever retriever = new ProductRetriever();

...will only have access to GetProducts and nothing else.

List<Product> myProducts = retriever.GetProducts();


Suffice to say, there's a whole lot more to scope than that. Diving into protected scope and such will lead you down the path to class inheritance, etc. If you really want to get your head around Object-Oriented code, I can't recommend the book Head First Object-Oriented Analysis and Design enough. The examples they use are in Java, but it's close enough and the concept carries almost directly over.

You sound exactly like me 10 months ago. I also took the plunge, moving from PHP/MySQL to C#/.NET. Keep in mind that I am not a .NET veteran, but I have gone from knowing nothing to developing all of my sites in it in just under 10 months.

• Object Oriented is a big part of it. If you know this from Java, great. If not, start there. I recommend Head First Object-Oriented Analysis & Design
  
  
• MVC - if you have used a PHP MVC framework you are going to have a much easier time of it. I did not, so I had to learn MVC, OOP, C#, and .NET all at once.
  
  
• Wrox ASP.NET MVC3 has been invaluable. My copy is covered in sticky notes and highlighter after reading, and I refer to it heavily.
  
  
• I just bought Pro ASP.NET MVC 3 Framework, and it also seems good, however, I like the Wrox book better.
  
  
• Pluralsight.com - A little pricey at $30 / mo, but they have a plethora of extremely high quality videos. If you have enough free time to make use of the monthly subscription, I do recommend it.
  
  
• When you come to databases, I highly recommend going the Entity Framework route. Most other things seem like garbage by comparison in my limited experience.

1. Learn the syntax of your programming language and the core API - http://docs.oracle.com/javase/tutorial/
   
2. Learn object oriented design - Head First Object-Oriented Analysis and Design
   
3. Learn design patterns - Design Patterns: Elements of Reusable Object-Oriented Software
   
4. Pick a platform - Applets, Android, Desktop or a combination. Core Java and design stuff will be the same but basic things like how you draw graphics or play sounds will vary. Usually you end up adding libraries or frameworks on top of Core Java to help you handle game specific things like graphics, sounds, input, etc. Some might be different across the platforms you want to support and others (LibGDX for example) try to be a single framework that supports multiple platforms.
   
5. Learn your platform/libraries/frameworks.
   
6. Make "retro" games with bad artwork or learn to also be an artist or how to find/hire an artist.
   
   Many game programming books start off at step 4 so you need to do 1-3 before you get into those books. Never get an old book for step 4, the game specific stuff gets out of date too fast. Anything that does 1-4 all at the same time probably isn't worth it.
   
   

There are some SUPER valuable insights in the replies of this thread that took me YEARS of programming to fully understand. So you did yourself a great service asking this question here :)

 

These insights are:

by u/cmd-t
> think in OOP in terms of passing messages from object to object. Every function call is actually sending a message to an object: a request for it to do something.

by u/saturnflyer
> Don't model the real world. Create the world you need.

by u/tom_dalling
> It's a common misconception that classes model real-world things. Classes model data, or behavior, or responsibilities.

 

To answer your question, yes, OOP is hard to master. As a result, there are many books written on the subject. And for a complicated system, even senior developers will have trouble getting the design right on a first try.

 

If you feel lost, it's not because you are not good at this. It's because the subject you are learning does require lots of time and practice.

IMHO, the best way to learn this is by actually working alongside with senior engineers in a real production project. So you can see some existing designs and also bounce ideas with other engineers.

While that might not be possible at the moment, you can

• look at existing designs of open source projects
  
• read books: Practical Object-Oriented Design in Ruby by Sandi Metz, Smalltalk Best Practice Patterns by Kent Beck These two might be a bit too advanced. I couldn't think of any good OOP introductory books of the top of my head, maybe Head First Object-Oriented Analysis and Design?
  
• practice and bounce your design ideas with other engineers
  
   
  
  Happy coding and I hope to see you posting more questions here! :D
  
  

I think the best way to learn is by doing, so I suggest doing a big project in Java. The Java documentation talks about object-oriented programming a lot and is a good read.

If you want something to read, this book looks a little kooky, but don't judge a book by its cover. It is probably one of the easier to read books on the subject, but still has a lot of good information

I've actually read most of these but I feel like there's some gaps....

I want to suggest this: Head First Object Oriented Design and Anlaysis

Ok, so first you do the analysis book. Because that's a great break into the conversation of good design.

Then you do Head First Design Patterns, then you jump into the Algorithm stuff.

Soft Skills save for last. Personally, I think the Programmatic Programmer is pretentious trash, so I don't know where that fits it, I hated it. Coding interview should be toward the end. Clean code should be early too.

If I can give a high overview

• Learn a Language
  
• Clean Code
  
• Analysis
  
• Design Patterns
  
• Algorithms
  
• Devops
  
• Managing Development Teams
  
  EDIT:
  
  You need to learn an object oriented language. So C# or Java, those are the most popular. But if I'm so summarize my experience so far. So, I learned a couple language (SQL and C#) then, I went into analysis and at the end of the analysis I went into GRASP patterns and then I went into the more complex patterns in the Head First book. From there, I then coupled learning generics alongside data structures. I felt they naturally complimented each other.

Maybe get a book? I've heard good things about the Head First series.

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:

Pragmatic Programmer



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.

https://www.amazon.com/Head-First-Object-Oriented-Analysis-Design/dp/0596008678

My other recommendation is that you get this person immediately implementing as many design pattern tutorials as possible because their usage comes in stages.

The first stage -- everything can be solved by patterns. This is where patterns are used excessively and without reason just because this is a new tool to work with.

The next stage -- sometimes a pattern is overkill. The programmer realizes that sometimes the problem can be solved more clearly and easily without implementing 9 patterns to do it.

After that -- I hate patterns. I hate classes. I hate OOP. I think I'll learn C.

Eventually -- Yeah, OOP works well for some things, and not so well for others. And, sometimes patterns are useful, but a lot of times it's not really worth the technical debt. So, I'll use discretion in introducing a pattern, and I'll try to keep it abstract enough that the pattern doesn't get in the way.

So, you can probably guess that these stages take a long time to get through. That's a lot of failed code, fragile code, brittle code before things get better.

This is why I suggest you start them on it while learning about OOP.

This series of books is also very good for beginners!

https://www.amazon.co.uk/gp/aw/d/0596008678/ref=mp_s_a_1_1?ie=UTF8&qid=1504991665&sr=8-1&pi=AC_SX236_SY340_FMwebp_QL65&keywords=head+first+design+patterns&dpPl=1&dpID=51mE7FBCw8L&ref=plSrch

Coming from HTML, you'll need to get your head around a few key words and concepts, object oriented programming, polymorphism, class hierarchy etc... It can be daunting at first but once you have the basics everything else is just application (which can take a while to get quick at).

Head first also have a design patterns book, which is useful if you're on a project which you're designing fresh...

Thanks! I've come across that book, and also another one, Head First Object-Oriented Analysis and Design LINK

Have you used this book? If so, which one do you find better for my situation? (Amazon user reviews says this book has quite a bit of errors and was rushed, leaving things out) :/

Programmer here.
"If you cannot explain it simply, you don't understand it well enough."

What I'm trying to say is that a good programmer can always find ways to simplify a concept, or explain it using real-life analogies, even to people who don't know anything about programming or computers in general.
This is actually one of the most important qualities of a good software developer - the ability to rationalize often complicated abstract concepts in simple terms and break them down into simple tasks.
I want to make this clear - I am not saying that your boyfriend is a bad programmer and I don't know his professional level.

However, it sounds like both of you could turn this situation to your own benefit.
If he makes an effort to explain his work in ways that you could understand, it would work in his favour in the long term, and you could share his excitement.
I actually recommend reading Head First Object-Oriented Analysis and Design: A Brain Friendly Guide to OOA&D for easy-to-digest examples of complex issues in software development, explained with tools and objects from everyday life, he could probably take a hint from that book and learn something.

Finally - big props to you for being a supportive girlfriend and taking interest in his work.

This book is chock full of good design patterns and written in Java. Much of the code will translate very nicely to TypeScript: https://www.amazon.com/Head-First-Object-Oriented-Analysis-Design/dp/0596008678/ref=sr_1_8?ie=UTF8&qid=1496408897&sr=8-8&keywords=object+oriented+programming

Of course, it's not the only book, but I found it really useful.

I've been writing a book on TypeScript and just finished the first cut at TypeScript classes. It has a number of examples. They are very simple, but get into interfaces, classes and so forth. Here's the link: https://pagalvin.gitbooks.io/yet-another-typescript-book/content/

Classes are covered in chapter 7 and especially chapter 8.