Raoul Gabriel

Tom Joe wrote:To the authors - Will you make a video companion for your book ? If yes, then how soon is it likely to be available ?

IMHO, video would be helpful for those who learn better by watching things. Many books from O'reilly and other publishers have companion video courses on O'reilly online. For example - Java - How to program by Deitel is a book and video too. Some authors only make video and no book. I hope your book will have video too.

PS - On some days, reading a book puts me to sleep quickly. But, a video on the same topic helps me stay attentive longer.

Hello Tom, that's a good idea & something we are open to. Although right now we are fairly busy so it's not an immediate project!

Rashmi varma wrote:Hello Sir,

I am a Java developer and these days preparing for interview in FAANG companies. I would like to understand if this book helps me understand the the design aspects when we start to build an application. What needs to be considered before we actually start coding and using algorithms? The right and clean way to go about the complete solution to the problem.

Thanks in advance,
Rashmi

Hello & thank you for your question. This books certainly will help you with the software design aspects when you start building a Java application. We do not cover interview-style algorithmic questions though.
There are broadly four themes in our book:

Java Features
Structuring code with classes and interfaces is discussed in Chapter 2. We move onto exceptions and packages in Chapter 3. You will also get a short overview of lambda expressions in Chapter 3. Then local variable type inferences and switch expressions are explained in Chapter 5, and finally lambda expressions and method references are covered in detail in Chapter 7. Java language features are important because so many software projects are written in Java, so it’s useful language to know the workings of it. Many of these language features are useful in other programming languages as well, such as C#, C++, Ruby, or Python. Even though those languages have differences, understanding the how to use a class and core OOP concepts will be valuable across different languages.

Software Design and Architecture
Throughout the book a series of design patterns are introduced that help provide you with common solutions to common problems that developers encounter. These are important to know because even though it may seem like every software project is different and comes with its own set of problems, in practice many of these have been encountered before. Understanding common problems and solutions that have been solved by developers keeps you from reinventing the wheel in a new software project and enables you to deliver software faster and more reliably.

The higher-level concepts of coupling and cohesion are introduced early on the book in Chapter 2. The Notification pattern is introduced in Chapter 3. How to design a user-friendly Fluent API and the Builder pattern are introduced in Chapter 5. We look at the big-picture concepts of event-driven and hexagonal architectures in Chapter 6 and the Repository pattern in Chapter 7. Finally, you’re also introduced to functional programming in Chapter 7.

SOLID
We cover all the SOLID principles throughout various chapters. These are a set of principles designed to help make software easier to maintain. While we like to think of writing software as the fun part, if the software that you write is successful it will need to evolve, grow, and be maintained. Trying to make the software as easy to maintain as possible helps this evolution, maintenance, and long-term addition of features. The SOLID principles and the chapters where we will discuss them are:

- Single Responsibility Principle (SRP), discussed in Chapter 2
- Open/Closed Principle (OCP), discussed in Chapter 3
- Liskov Substitution Principle (LSP), discussed in Chapter 4
- Interface Segregation Principle (ISP), discussed in Chapter 5
- Dependency Inversion Principle (DIP), discussed in Chapter 7

Testing
Writing reliable code that can be easily evolved over time is really important. Automated tests are key to this. As the software that you write scales in size it becomes increasingly hard to manually test different possible cases. You need to automate your testing processes to avoid the days of human effort it would take to test your software without it.

You learn about the basics of writing tests in Chapters 2 and 4. This is extended to test-driven development, or TDD, in Chapter 5. In Chapter 6 we cover the use of test doubles, including mocks and stubs.

Hello & thank you for your questions!

Junior software developers, often just out of university or a couple of years into their programming career, are who we think of as the core audience for this book. You’ll learn about fundamental topics that we expect to be of relevance throughout your software development career. You don’t need to have a university degree by any means, but you do need to know the basics of programming in order to make the best use of this book. We won’t explain what an if statement or a loop is, for example.

You don’t need to know much about object-oriented or functional programming in order to get started. We make no assumptions beyond that you know what a class is and can use collections with generics (e.g., List<String>).

Another group who will find this book of particular interest is developers learning Java while coming from another programming language, such as C#, C++, or Python. This book helps you quickly get up to speed with the language constructs and also the principles, practices, and idioms that are important to write good Java code.

Hello and thank you for your question! Our book covers the former part of your statement "the software concepts like code designs, implementation with respect to core programming".

The book covers hands-on principle to apply to your code and programming practices that will help you develop software that is maintainable as well as robust to changes. This is done by covering key design patterns as well as best practices for testing. Along the way, we introduce modern Java features introduced in Java 8 (lambdas, method references), 10 (local type variable inference) and 14 (switch expressions)

To add to Richard's very good answer. The book also covers switch expressions which were in language preview in Java 12 & 13 and is now officially part of Java 14!

Hello and thank you!

As a follow up, here's the updated ToC! Stay tuned :-)

PART I: FUNDAMENTALS
1 Java 8: why should you care? - FREE
2 Passing code with behavior parameterization - AVAILABLE
3 Lambda expressions - AVAILABLE

PART II: FUNCTIONAL-STYLE DATA PROCESSING
4 Processing data with streams - AVAILABLE
5 Collecting data with streams - AVAILABLE
6 Parallel data processing and performance - AVAILABLE

PART III: EFFECTIVE JAVA 8 PROGRAMMING
7 Refactoring, testing, debugging
8 Default methods - AVAILABLE
9 Optional: a better alternative to null - AVAILABLE
10 CompletableFuture: composable asynchronous programming
11 New Date and Time API

PART IV: BEYOND JAVA 8
12 Functional programming: tying the pieces together - AVAILABLE
13 Blending OOP and FP: comparing Java 8 and Scala
14 Conclusions and "where next" for Java

APPENDICES:
A Miscellaneous language updates
B Miscellaneous API updates
C Performing multiple operations in parallel on a Stream
D Lambdas and bytecode

Hi Gauri,

Thanks! You can't set a limit to the number of repetitions allowed.
But, yes in a nutshell repeatable annotations are just a syntactic sugar. Instead of using an explicit container inside the annotation:

@Authors(
{ @Author(name=”Raoul”), @Author(name=”Mario”) , @Author(name=”Alan”)}
)
class Book{}

you can more simply write:

@Author(name=”Raoul”) @Author(name=”Mario”) @Author(name=”Alan”)
class Book{ }

It will clean things up in enterprise applications where they often make use of this idiom.

Hi Baskar,

Lambdas can enable you to do testing in a more declarative BDD approach. See this link for an example: http://www.blog.project13.pl/index.php/coding/1830/proof-of-concept-lambdaspec-how-testing-will-look-with-java8/

Hi Carlos,

To have a quick idea of the benefits of lambdas in 10min, I suggest you watch the video we made on this topic: http://www.youtube.com/watch?v=Rd-sqHjmfB0

In a nutshell, it lets you write more concise code and cope for requirement changes.

The best learning path is to read our book ;-) Otherwise I'd recommend watching a few lectures/videos on youtube. This website will give you a quick access to all java 8 updates: http://www.techempower.com/blog/2013/03/26/everything-about-java-8/

By the way, we've had a discussion based on your feedback. We've decided to have a chapter on the new date and time API instead of an Appendix.
It will come under Part III "Effective Java 8 programming"!

Thanks,
R

Hi Ralf,

we renamed the chapter "Refactoring, Testing, and Debugging". The new ToC will be updated soon and the content should be up shortly. In a nutshell, this chapter has more emphasis on refactoring: we discuss patterns to apply in your code and how typical object-oriented design patterns can be refactored using lambdas

Regarding debugging, you can set break points in a lambda expressions as you would normally do in your code. However, make sure the lambda is on multiple lines so you can set a line individually. Similarly for a stream pipeline. Instead of writing:

stream.filter().map().reduce()

You should write:

stream.filter()
.map()
.reduce()

So you can set break points on the individual operations.

The Debugging section specifically discusses on to examine stack traces (lambda expression makes things slightly less readable) and how to debugg/log information in a stream pipeline using the operation peek().

Congratulations! We look forward to your feedback :-)

For the others, if you are interested in our book, you will find a 38% discount code when watching the video we made that explains "first-class functions in Java 8":

Hi Krystian,

We assume two years of experience with Java (e.g. you should know what a Thread is and recognise use of generics).

We've designed the book so the knowledge you acquire gradually builds up and is immediately applied in the next chapter. We've added many quizzes with solutions along the way to help during the learning journey!

As for topics, we've covered all important Java SE 8 topics in details. We've also recently added appendices to cover other language updates (e.g. annotations, general target typing) and library updates (collections, arrays, concurrency etc). The new ToC will be reflected very soon on our book webpage http://manning.com/urma

To get a taster for our book and how we explain things, you can get started with this video (and you'll find a 38% discount code ;-)): www.youtube.com/watch?v=Rd-sqHjmfB0

Hi Tim,

Java 8 doesn't provide a new immutable collection library. However, Java has "unmodifiable" collections, which is a bit different.

For example, in the code below the variable newNumbers is a read-only view over the set numbers:

Set<Integer> numbers = new HashSet<>();
Set<Integer> newNumbers = Collections.unmodifiableSet(numbers);

This means you won’t be able to add new elements through the newNumbers variable. However, an unmodifiable collection is just a wrapper over a modifiable collection. This means that you could still add elements by accessing the numbers variable!
In comparison, immutable collections guarantee that nothing can change the collection anymore, regarding how many variables are pointing to it.

We have a whole chapter dedicated to Functional Programming (currently chapter 11) where we discuss how you can get tripped up with mutation (one of the example involves lists). We also present the notation of immutable ("persistent") data structures. In addition in the next chapter where we compare Java 8 and Scala, we briefly discuss how Scala collections are immutable.

So I invite you to have a look :-) We are making additional updates to this chapter in the next couple of weeks to strengthen it with more examples. All feedback is welcome!

Thanks,
Raoul