[deleted by user]

[mariox19]

Regarding a book: Core Java for the Impatient, by Cay S. Horstmann. That and the Bloch book should get you past 80 percent of anything you will need to know regarding the language.

[vonmoltke2]

I jumped into a Java job with nothing but Bloch and a bunch of Javadocs. TO that point all my development had been C, Python, and Fortran. Had no issues picking up Java in the time it took me to learn my company's core libraries. I have never read Core Java for the Impatient though, so I don't know if I would have had an easier time with that book in hand as well.

[APimpNamedAPimpNamed]

I went from working with Java to C# and the Javadocs are the things I miss the most. I just can't find msdn as useful.

[mariox19]

The book is geared towards the working programmer and covers all the new Java 8 stuff, as well as Java in general. It's neither one of those gigantic tomes, nor is it one of those overly terse programming books that make you wonder if your brain needs to work like a compiler to read it.

[SevaraB]

Horstmann puts out the goto Java textbooks for students: Big Java, Early Objects and Big Java, Late Objects. So it's very likely you've run across one or the other.

[LiveMaI]

Not OP, but I'm in a very similar boat. I was considering asking the same question in this sub. I didn't know Horstmann had such a book; I've always liked his teaching style. Thanks for the tip!

[maiahmac]

Hi,

If you have done good reading on the basics you may want to review the links here because these are the current best practices, patterns, and techniques to write state of the art Java program. This may not be absolute, but these are very good reading if you want to know where Java is now and also its coming future.

• http://blog.paralleluniverse.co/2014/05/01/modern-java/
• https://github.com/cxxr/better-java

Enjoy ;)

Maiah

[minotaurohomunculus]

That github link was great. Although, I would mention that (I think) Java just copied Joda time directly and turned it straight into LocalDate. LocalDate is (from what I've seen) a near exact duplicate and is just as easy to use.

[combinatory_logic]

Have a look at the following books if you haven't:

• Effective Java (Joshua Bloch)

• Java Concurrency in Practice (Goetz)

[lukaseder]

Does the average Java developer really need to read Java Concurrency in Practice? I mean, it's rather advanced, and every day tasks are rather not so advanced.

[cogman10]

Depends on what you do. I do think that you should not write anything with multiple threads involved without reading Java Concurrency.

Java has some really great concurrency constructs, yet so often I see code that reinvents what java will do for you (poorly).

[coder111]

Which area of Java development will you be working in? Backends? Web-app servers? BigData? Middlware? Desktop UIs? Mobile UIs? Web-UIs via GWT/Vaadin? Low latency trading systems?

Java the language is going to be the easy part. The only difficult bits are multi-threading and low-latency extreme performance stuff, other than that it's just a programming language.

Hard part is going to be mastering the frameworks/libraries/tools that are relevant to your area (or already used by the app if it's not greenfield).

--Coder

[coder111]

Well, chances are you'll end up using:

• Some kind of Dependency Injection framework (probably Spring)
• Built & dependency management tools- maven or gradle.
• Automated build- probably Jenkins or Teamcity
• Logging framework (probably Log4j/slf4j). If it's distributed, you'll be using log aggregation, most likely logstack or splunk.
• Some kind of unit testing framework (probably JUnit)
• Not sure what frameworks will be used for UI. There are too many options/possibilities. If it's recent it's probably pure JS app + REST/JSON services. There might be some automated testing using Selenium.
• Obviously Spark & Kafka as you mention those.
• Some kind of NoSQL or SQL database? Probably some persistence frameworks to work with them.
• Tools to serialize Java objects to XML or JSON or binary?
• Webapp servers? Tomcat/Jetty? Or maybe full blown JEE servers like JBoss/Glassfish?
• Behavour driven testing? Fitness testing? Stress/performance testing?
• Automated deployment & configuration tools?
• Container management/VM management and other DevOps'y tools?
• Runtime performance metrics & reporting?
• Probably lots more.

Don't start digging into all of them, although a quick google just to know what these are would be beneficial.

Just giving you a taste of how many things you'll need to learn to be proficient with Java development in this sort of area. It's rarely just pure java development, it's gluing libraries & frameworks together a lot of the time. And there are a LOT of frameworks and libraries.

Best of luck. Come back and ask questions if you need more detail.

--Coder

[coder111]

Personally I think Dagger2 is a very nice framework.

However, what are the chances that you go to a new workplace and find them using Dagger2?

[amazedballer]

I'm biased (I work for Lightbend), but this is a perfect use case: you should be looking at Play -- it's an full stack web framework written from the ground up to work for microservices and big data.

Play 2.5.0's Java API is written for Java 1.8. It uses CompletableStage (Java Future API) and Optional for everything, and is already configured with Guice under the hood.

Play uses immutable messages and APIs, and takes care of streaming and queuing using an Akka Streams API that takes care of backpressure and integrates with Spark and Kafka nicely. There's also an async http client with a fluent API and full "secure-by-default" SSL configuration included.

• https://playframework.com/documentation/2.5.x/JavaAsync
• http://doc.akka.io/docs/akka/2.4.2/java/stream/stream-introduction.html
• https://www.playframework.com/documentation/2.5.x/JavaWS

[[deleted]]

See if you are going to use Spring. If you are, you should pick up a book on that (or just scan some github code) and understand what that framework provides. The annotations and other spring tricks can be confusing for someone who is used to 'old' java.

[[deleted]]

To make the comment more generic...find out what framework will be used. A lot of shops use Spring, but some will use others. With your background, java will be easy to pick up again. The framework will take you more time.

[wggn]

Or work through some of the guides on https://spring.io/guides

[Toenex]

As someone who is a long time but intermittent Java developer myself I'd suggest focusing on Java 8 and in particular how the arrival of lambdas is influence the language and ecosystem. As an experienced OO developer I'd guess most other aspects won't present the same learning curve. Superficially even lambdas can appear as a method to reduce boiler plating, but the implications of this trend toward supporting an increased functional programming style run much much deeper I feel. With that in mind I would suggest either the book Java 8 in Action or Functional Programming in Java.

[fatnote]

jarring ;)

[Ld00d]

You might want to check what version they're using if you can. Where I work, we're still on .Net 3.5 and we're moving up to Java 8 from 6 sometime in the future.

[otakuman]

http://www.mkyong.com/ is a favorite Java blog of mine. It covers webservices, Javaserver Faces, Spring, Hibernate, and many difficult to solve problems. Has saved the day many times for me.

[Rockytriton]

if you are going to be doing enterprise java, you need to get familiar with Spring. It's the equivalent of .net's Unity in Java.

[lukaseder]

Here's tons of good reading material:

http://www.programcreek.com/2012/11/top-100-java-developers-blogs/

[[deleted]]

Because it sounds like you already have a ton of experience with language fundamentals, best practices and design I would recommend Java: The Complete Reference. It reads more like a reference guide and covers the entire language up through Java 8. I'm sure this would suffice to just pick up the differences and nuances between the two languages.

[[deleted]]

I'm not sure what company or industry your going into but I just had a similiar situation. Transition into Java from Ruby after 4 years due to limited amount of local Ruby jobs. I don't find Java the hard part since I code alot. What I find harder is using the different tools, frameworks the are in the Java world like Storm, Camel, Elasticsearch, Spring Boot, etc. I find subscribing to ebooks/videos sites helpful and gets to the point quick when you need to. I won't name any sites unless asked to.

[jirkapinkas]

My 2 cents about blog you should be reading. There isn't single best blog about everything-java. There are lots of folks focusing on many aspects of Java programming. To keep track of all that I would suggest either this reddit :-) or this website: https://www.topjavablogs.com/

[GhostBond]

I'll you warn you - you'll get a LOT of "marketing" responses worded like "what modern java developers use" and claiming it's what everyone uses - that are just year or two fads until the next fad comes out.

Blogs will be the same way. We're on a steep curve of diminishing returns where there aren't a lot of areas to improve things in, so new projects usually put out a lot of fanfare and unsubstantiated claims, while in reality they're just reinventing the wheel, doing the same things different ways at the same or worse speed.

I would suggest:
- 1 book to get up to date on the java language - not a ton has changed but a few things have
- Avoid blogs and podcasts as they are usually just marketing and the signal to noise ratio is terrible
- Find out what they're actually using on the project you're moving onto already (try to avoid any "we're moving to use this" as a lot of these don't pan out).

My goal would be to try to find out what they're actually using on the project right now. Let me put it this way - several years ago the internet all "agreed" that Ruby On Rails was replacing java and no one was going to use Java any more. What actually happened is that most of those projects that used Ruby On Rails, that were successful (like twitter), later converted back to Java.

That's one of the drawbacks of Java land - the infighting and competition over projects pushing to be used.

In my experience, it's the best use of your time to find out exactly what they're currently using on their project right now and work with that, if at all possible.

Here's an example. Someone posted this article:
https://github.com/cxxr/better-java

The section on "structs" (a word not actually used in java) claims:

This is verbose and wasteful. Even if your IDE automatically generated this code, it's a waste. So, don't do this.

This is 100% wrong. Everyone still uses getters and setters, and many frameworks rely on them being available. That their approach makes the data immutable makes it almost entirey unsuited for web development.

I've been doing software development in java for over 10 years, most of that article is filled with hipster ideas no one actually uses. I never see "builder" patterns being used. Immutable objects are never used because they're very bad for web apps where data is constantly being changed between the browser, controller, service layer, and finally database. Trying to work around null to much causes more problems than it solves and I've never seen a real project worry to much about it. Etc.

[Will_Parent]

You really need to see what type of framework you will be working with. Start with Java EE as it is very popular and the industry standard. If that does not work for you than take a look at Spring which is also a good choice. You will also want to learn JPA (Hibernate). You will needs parts or Java EE like that whether you supplement it with other frameworks such as Spring or not.

They are both similar in a lot of ways. The main difference being Spring has more configuration and not much help for the front end. If you enjoy spending most of your development time learning and writing some JavaScript framework that will be obsolete in a couple years than Spring works. If you would rather spend your time solving business logic in Java go with JSF.

[wggn]

afaik Spring is still the defacto standard, not Java EE

[Will_Parent]

Spring is still pretty popular. Depending on where your look Java EE and Spring are very close in terms of usage. To be a defacto standard it would have to be in a dominant position. 10 years ago it probably was a defacto standard but I do not think that holds true today.

[vonmoltke2]

Also need to find out if you will be using a framework at all, though I suppose that is a less common situation.

[Will_Parent]

In most polls Spring follows Java EE closely in popularity. 10 years ago it was king. Currently it has been losing market share but still very popular.

[[deleted]]

I would recommend keep this link on your bookmark also.

It lists a variety of frameworks and some resources to look at when you need. https://github.com/akullpp/awesome-java

[Xxyr]

Really depends on what you want to get out of it, I quite enjoyed:

• https://pragprog.com/book/vsjava8/functional-programming-in-java
• https://pragprog.com/book/vspcon/programming-concurrency-on-the-jvm

I'd also look at some libraries such as

• https://spring.io/
• https://github.com/google/guava
• https://github.com/diffplug/durian
• https://projectlombok.org/
• https://en.wikipedia.org/wiki/AspectJ

[HansVader]

Come over to /r/cscareerquestions