(Part 2) Best products from r/java

I can't talk about Schildt's competence on Java. I know about his C books, which are pretty much recommended to be avoided. Bruce Eckel's on the other hand, I've heard only good about his materials (although I didn't really like his design patterns book very much). I've never read the two books you've mentioned though.

Have you tried the official tutorials for learning Java? They're very good IMO. They're freely available too.

My first book on java was The Java Programming Language (it teaches Java 5 [current version of java is 8]). Except that you'd be learning Java 5, which is still fully applicable, this book is very good. One of the authors is the creator of java, another is Guy Steele. He's a programming languages expert whose books I believe are worth reading just because he wrote it. He's pretty above the average, and also one of the creators of Scheme. Look him up on wikipedia =D.

I've read Core Java too (it has pretty up to date editions). I found it good, which is a win on its own since most learning sources are terrible IMO, but I didn't find anything particularly interesting about it. It does cover a lot of ground, though. I surely recommend it.

A lot of writing good java code is about understanding the usual patterns of which people make use.

The author of Core Java has a book on this (http://www.amazon.com/Object-Oriented-Design-Patterns-Cay-Horstmann/dp/0471744875/). I've never read it, but I'd guess it's good. I don't know how advanced it is though.

You can, of course, always look up the Design Patterns book (http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/). I'd not recommend reading this before learning java. I think you should only do it after learning some java. Although I don't think it's a particularly challenging book, I think it'll make a lot more sense given you can see its code examples (mostly in C++, and some in smalltalk; but mostly in C++) and understand what they do. You don't need to really know C++ for that, honestly. The code doesn't make use of any (IMO) advanced features of C++. Knowing java and using common sense I think is enough to understand what is in there.

There are many books on better using java. If you google for good java books, you'll find plenty of reviews, recommendations, and so forth. You can search amazon too.

By the way, a lot of the programming techniques for writing good code in one language can be learned by studying materials in other languages. For example, I owe much of my programming basis knowledge to K&R2 (The ANSI C Programming Language - 2e), SICP (Structure and Interpretation of Computer Programs), The Little Schemer, and The Seasoned Schemer. These books teach in C and Scheme (two languages that I probably will never use professionally), but a lot of what they teach I've been able to apply while coding in C++, Java, JavaScript, PHP, SML, Python, and also other languages I've used in the past.

Good luck.

1. You should try picking up anything you find interesting and make an effort to never stop learning. I understand you didn't like your job, but that was really no excuse to stop developing yourself. You can join coding groups, partake in hackathons, etc. to keep yourself learning and more viable/marketable in the industry.
   
   
2. If that is where your interests lie. Honestly I leave things I know off my resume just because I know I would be unhappy doing them full-time.
   
   
3. It really depends on what you meant by 'you didn't do well at interviews'. Did you flub a lot of programming questions that you should have gotten? Then yes. Learn more programming nomenclature and processes. Of course, no company is going to expect you to know every single thing they ask. A lot of the times they are just seeing how you respond to being in a difficult position. That brings us to the next question: did you flub interviews because you are not as strong as you could be in the communication department? If that is the case then maybe you should find a local Toastmasters group and get some public/small group speaking experience under your belt.
   
   
4. Yes. Join an open source project. Write some proof of concept things using new technologies. Polish them and show that you are a developer who cares about their code. Companies will guaranteed look at your github profile.
   
   
5. There are plenty of .NET jobs out there. Maybe you should start a .NET personal project and throw the code up on github?
   
   
6. I wouldn't necessarily say you need to be an expert, but you should know what direction Java is headed in and show an interest in it. I would recommend this book if you want to quickly assimilate the key points of 8. Again, this just shows companies that you really do love programming and care about what is new and what is on the horizon.
   
   
7. Be honest: tell them you were fired, what lead up to it, what you learned from the experience, and that it was a wakeup call that has lead to you working diligently towards personal development in the future in order to avoid a situation like that again. Then drop it and get back to your interview.
   
   
8. Who knows. All you have told us is that you didn't like the work you were doing. Do you like the business logic side of it? Maybe you should be a BA. Do you like trying to break software? Take your programming skills and get into QA testing. Finding out you don't like computers? There's always Peace Corps. Find a passion. I started my professional career as a physicist but fell into comp sci due to lack of jobs/money. I haven't regretted it a single day and I love my job. Because of that I push myself to learn more which in turn leads me to higher salaries and bigger titles, which makes me love my job even more. Sure it gets tedious some days, but good luck finding a job that doesn't.
   
   TL;DR: Figure out what you want to be when you grow up and start pushing in that direction.

>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."

Since you want to learn java and esp. OOP, I would say start with a good book. I like Core Java Vol. 1 and Core Java Vol. 2 but you can start with any book you like.

Download Java from Oracle since they have version 7 for Lion.

For editor, I would stay away from any full featured IDE like Netbeans or Eclipse in starting phase. Start with TextEdit or Sublime Text. Write few code by yourself and compile it using Terminal. This way you will learn the compilation process. All IDEs compile files automatically so you can't learn what is going on behind the screen. If you use command line, you will also learn CLASSPATH, packages, class creation etc.

You should use command line for first 2-3 months only or may be less depending upon your learning curve. After that you can choose IDE. By that time, you will also good knowledge to judge which IDE is good for you. Netbeans and Eclipse both are good and free. I like Netbeans.

Good luck with your learning process.

We assign mentors (usually the more experienced team members, but can vary depending on project and resourcing requirements) to new guys who will help them get to grips with things like our methodologies, coding standards, etc.

If we end up with a team consisting of a lot of guys without TDD experience (rare, but my teams can vary depending on other projects/resources within my company), we'll occasionally run TDD workshops where one of my senior guys or myself will go through a fill worked example of TDD, and then point the new guys in the direction of suitable resources so they can self learn (although we support them as much as required).

In terms of resources, there are a number of books we have on our internal "recommended reading" list:

1. The Clean Coder : A Code Of Conduct For Professional Programmers by Robert C. Martin (http://www.amazon.com/The-Clean-Coder-Professional-Programmers/dp/0137081073). This is a good book for developers in general, but has a good section on TDD.
   
   
2. Test Driven Development : By Example by Kent Beck (http://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530/ref=sr_1_1?s=books&ie=UTF8&qid=1458766760&sr=1-1&keywords=kent+beck). Kent Beck is one of the leading proponents of TDD, and this is well worth a read. I find that the fact the text is example driven really helps our developers relate TDD principals to actual real life situations.
   
3. xUnit Test Patterns : Refactoring Test Code by Gerard Meszaros (http://www.amazon.com/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054). This is a bit more advanced and goes above why and how to use TDD - in fact, it's not specifically about TDD, but rather just unit tests in general. However, it explains ways and patterns that can be used to design your code and your tests correctly in order to produce quality tests.
   
   There's a lot of information on the web, but I find sometimes books are just the best source.

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

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

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

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

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

Buy a printed copy of Head First Java and Sun Certified Programmer For Java.

First, read Head First Java completely it is very easy to understand with lots of animated diagrams and then read Sun Certified Programmer For Java it will give more clarity and depth. It also has summary for each chapter which will help you revise the things in future.

Please also complete the examples and exercises, it will give good grasp and help you remember.

The best book for a deep understanding(not for fresh users) with tons awesome notes.Matters Computational: Ideas, Algorithms, Source Code

Author publishes that book absolutely free on his website

https://www.jjj.de/fxt/fxtbook.pdf

Or you can buy the book on Amazon:

https://www.amazon.co.uk/Matters-Computational-Ideas-Algorithms-Source/dp/3642147631

You can also check out the Java tutorials and the Java EE tutorials, but these might be a little on the light side compared to books devoted to the topic.

The Core Java Volume I and Core Java Volume II by Cay Horstmann are the best books I've read for learning Java. Some people like the Head First series.

Effective Java is a must read.

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

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



Just.

Please.

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

This is as good a place to start as any. https://www.youtube.com/watch?v=wgdBVIX9ifA

This video was helpful too: https://www.youtube.com/watch?v=e0E6po7tG-8&t=533s

This book is pretty good https://www.amazon.ca/Building-Microservices-Designing-Fine-Grained-Systems/dp/1491950358/ref=sr_1_1?ie=UTF8&qid=1549050596&sr=8-1&keywords=microservices (updated version coming out in august)

Sure, glad I could help. It sounds like you're having some difficulties with the fundamentals of object-oriented programming. The Java tutorials are good, but they are focused on the Java specifics and don't really go into the bigger picture.

For that, I would highly recommend Agile Software Development, Principles, Patterns, and Practices by Bob C. Martin.

I have been reading a lot of java books, at the beginning was like a hobby, finally I recommend you OCA & OCP for java 8, good books, well explained, it teach you java in deep parts plus I can help you to certificate yourself, I read them 2 times, last week I bought and I read them again, here is the link:

https://www.amazon.com.mx/OCA-OCP-Java-Programmer-Certification/dp/1119272092/ref=sr_1_1?__mk_es_MX=%C3%85M%C3%85%C5%BD%C3%95%C3%91&keywords=ocp+java&qid=1558450747&s=gateway&sr=8-1

didn't read it, but from the index and reviews I read about it it seems good: http://math.hws.edu/javanotes/

for me I started with this book: Java how to program
it contains all the basics for J2SE so you will have an idea about each topic and you can expand the knowledge on your own.

if you are a beginner stay away from design patterns and effective java, once you learn the basics of the language and OOP you can move to these, also stay away from certification books, they are not for learning a language but rather for passing an exam.

I'm only about 6 chapters into volume 1, but I'm really enjoying Core Java by Cay Horstman and Gary Cornell. It assumes previous programming knowledge. My only issue with it so far is that there are no exercises to work through.

I also hear Thinking in Java is the defacto standard on how to learn it though, but I don't know if it assumes previous programming knowledge or not.

I started with C++ so the C++ comparisons throughout are helpful to me.

If you're interested in Core Java:

Volume I - http://www.amazon.com/Core-Volume-I-Fundamentals-Edition-Series/dp/0137081898/ref=dp_ob_title_bk

Volume II - http://www.amazon.com/Volume-II-Advanced-Features-Edition-Series/dp/013708160X/ref=pd_sim_b_1

I suggest the following resources:

Travery Media: https://www.youtube.com/user/TechGuyWeb

He covers React and Docker among MANY things.

Perhaps start here: https://www.youtube.com/watch?v=UnTQVlqmDQ0

If you like the guy's presentation he has complete Udemy courses.

Perhaps you may also want to learn about microservices: https://microservices.io/ before tackling Kubernetes.

My background is similar to yours so for my current project I using the following Stack: MongoDB, Spring Boot for a RESTFul back end and React. This book helped me a lot but it was not enough: https://www.amazon.com/Hands-Stack-Development-Spring-React/dp/1838822364/ref=sr_1_2?keywords=spring+boot+react&qid=1565195599&s=gateway&sr=8-2 Although very superficially, it covers all the pieces needed, like authentication using JWT and deploying to Heroku.

You don't need no know EVERYTHING, it is actually impossible, for example, l say pick a front end framework between Angular, React or Vue and learn only one and stick with Java for your back end. Oh, and don't believe all the hype... I see a lot of people trying to shoehorn stuff into their projects because it is the cool new thing.

Today the defacto way to design something is though tests. Some people might disagree with me here but I believe that Test Driven Development can help. You may want to do a small top level design but before you write any code you must always write the unit test for that code first. This way you can see how it is going to be used before you spend time coding it. Each of your tests should represent a piece of functionality in the code base. As you write each test you implment just enough code to get it to pass before you move on to the next one. Never regressing by letting old tests fail.

I usually start with a top level class and work out it's relationship to other objects in the design through interfaces. Then I'll write tests for each of the dependent objects and work top down like this. This is known as the London style TDD. There are other ways as well.

I reccommend this book:

Growing object orientated design through tests

Also this one, (but it's a bit long winded and it's a different style of TDD)

Test Driven - Kent Beck

Also, for those interested, you can buy the 8th edition of this book used on Amazon for a fraction of the cost of the 9th edition. A quick comparison of the table of contents shows an almost identical chapter structure, and there was less than 2 years between publications, so it's likely that not much changed between the two books.

Someone more knowledgeable in JAVA updates and the differences between them could probably better answer if anything significant happened between 2009 and 2011 that would justify the difference in cost between the two editions.

Amazon link to 8th Edition

Amazon link to 9th Edition

You can't go wrong with these two books:
http://www.amazon.com/Java-Puzzlers-Traps-Pitfalls-Corner/dp/032133678X/

http://www.amazon.com/Effective-Java-Edition-Joshua-Bloch/dp/0321356683

Joshua Bloch is a good author and was involved in implementing the Java API (collections API, etc.) early on...

You can also find several talks he's done online for Java puzzlers.

Some good presentations online (including some puzzler ones):
https://www.youtube.com/results?search_query=joshua+bloch

I used the 2nd edition of this when I was studying Java. It was good then so I'm assuming the later versions are just as good. http://www.amazon.com/Data-Structures-Algorithms-Michael-Goodrich/dp/0470383267

The assumption that you can't get a job and avoid Hibernate is a self-fulfilling prophecy. I've used--and insisted on--Jdbi at my last two jobs and it did not hurt my prospects in any way.

​

Let's get specific about the reasons for avoiding Hibernate / JPA:

​

JPA takes from you both control of, and visibility into, the SQL statements executed by the framework.

​

It sets in stone (based on annotations) once and for all use cases which secondary queries will be run and which columns will be selected any time a certain type is retrieved from the database--regardless of whether the use case at hand calls for it. This dramatically hurts performance.

​

It is difficult to predict how it formulates SQL commands based on your annotations, requiring testing and SQL logging just to make sure Hibernate is doing what it should.

​

JPA is tricky to configure, with myriad corner cases that frequently require extended debug sessions. Fun fact: debugging through Hibernate's internals is hellish. Thought you were going to spend time developing that new feature? Fuck you, first you have to spend hours to days figuring out how to coerce Hibernate to do this thing that would be trivial in plain JDBC.

​

JPA conditions developers to think in terms of the limited models that JPA supports, blinding them to all the other cool shit DB vendors support. "Well, Postgres has native support support for HSTORE but JPA doesn't support it, so we just added added a separate key/value table off the main table to hold those entries."

​

But by far, the worst, most egregious design decision was the combination of sessions and lazy loading. Hey, let's take a straightforward database query and obfuscate it behind unintuitive framework logic, because we're smart for you! Let's be super fucking clever and make it so navigating an object graph incurs database operations invisibly--for convenience! You probably didn't need most of that data we loaded, but you're welcome anyway.

​

Hibernate went too far. They tried to SOLVE ALL THE PROBLEMS instead of just giving us what we needed: a data access layer.

​

We don't need object-relational mapping! We don't need a session cache. We sure as fuck don't need open-session-in-view. We just needed something to make plain old SQL approachable (more approachable than JDBC, at any rate). Instead we got this:

​

https://www.amazon.com/Wenger-16999-Swiss-Knife-Giant/dp/B001DZTJRQ

​

Java devs need to start embracing SQL for what it is, and stop trying to shoehorn it into an object-oriented paradigm.

​

JPA is an albatross. Run, do not walk to the exits.

The Core Java books are a great resource.

Java and JavaScript are completely different. However programming languages share similar structures in general.

I like the book (AMAZON LINK) Java, How To Program, 10th Edition

Find a copy of this:

http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/ref=sr_1_3?ie=UTF8&qid=1300812062&sr=8-3

If you really want to learn all of (most of) the "Why" crap up front. I got a copy at a used bookstore for $4.

However, you don't worry about learning WHY it goes there, just learn to realize WHEN it needs to go there. It has to do with statement termination, so the compiler can properly convert your code to machine code.

I came at programming with your same mindset "why" but I realized that the answer is usually "doesn't matter to me" so then I started focusing on "when" and I realized that the "why" question eventually answered itself down the line at a time when I was better able to grasp it anyways.

If you want to get a head start at the college, I'd rather get more fundamental programming knowledge. Get a book about algorithms and datastructures (e.g. this or this, first few Google results pointed me to a PDF).

Well of course practical knowledge is also never bad.

I really like Java Puzzlers.

I liked "Core Java", but it is not as concise as Kernighan/Ritchie.

We used HeadFirst Java and Data Structures and Algorithms in Java

for my first year


Source:

http://www.amazon.ca/Head-First-Java-Kathy-Sierra/dp/0596009208/ref=sr_1_sc_1?ie=UTF8&qid=1405444231&sr=8-1-spell&keywords=HeadFirst+hjava


http://www.amazon.ca/Data-Structures-Algorithms-Michael-Goodrich/dp/0470383267/ref=sr_1_1?ie=UTF8&qid=1405444258&sr=8-1&keywords=data+structures+and+algorithms+in+java

Java How To Program (first edition):
https://www.amazon.com/Java-How-Program-9th-Deitel/dp/0132575663

http://www.amazon.com/The-Programming-Language-2nd-Edition/dp/0131103628 This is still the go-to book for C. Much more than 6 years old now.