T Vergilio

Hi Jeanne/Scott,

I hope you are both well. This is only a minor issue on page 565, last sentence of the section entitled Linking Streams to the Underlying data:

"First, it looks at the source and seeing three elements."

Did you mean to develop the thought process further here?

I'm enjoying the book so far, it is even better than previous editions. I love how the essential information is logically summarised in tables throughout the book. Really, really clear approach to organising the content!

Awesome! Thanks for the quick reply 🙂

Am I right to believe there is no upgrade exam from OCPJP 8 to 17?

Could I simply prepare for and sit the 1Z0-829 exam? Or would I need to take the associate level again?

Many thanks 🙂

Hi Kamal,

That's an interesting perspective, I haven't so far come across anyone trying to debunk the all-pervasive risk of vendor lock-in which is (presumably) inherent to the cloud.

I am looking forward to reading your take on it

Hello Tom, Kamal, Erik and Piyum. Welcome to the forum, and congratulations on the book publication

I had a look at the table of contents, which seems very interesting, as I am a researcher of cloud-based architectures myself. One question I have is whether you addressed vendor lock-in mitigation in your book. There are different ways in which this can be achieved, such as, for example, by having hybrid or multi-cloud set-ups. I am very interested to hear if this was a consideration of yours, and what your approach is to mitigating it.

Thank you very much.

It does look like Kubernetes is leading the way when it comes to decoupling the orchestration tool from the container technology though.

It might indeed not be in Docker's interest to make Swarm container-agnostic. From what I understand, the fact that Swarm mode comes as standard with the Docker engine is one of the differentials that would sway implementers towards using Docker instead of an alternative. Time will tell, I suppose.

Marko Luksa wrote:
On a related note, Kubernetes no longer needs to use Docker underneath. It can also use CRI-O or any other Container-Runtime-Interface-compatible runtime, including the Mirantis Virtlet, which spins up VMs instead of containers.

Interesting. On the one hand, the orchestration tool is now decoupled from the container technology (it no longer needs to be Docker). On the other hand, the only orchestration tool currently offering this is Kubernetes, which limits your options. Are you aware of any efforts from Mesos or Docker Swarm to catch up on that?

The outage you were referring to was much more recent. I'm a bit surprised Amazon didn't follow their own advice, to be honest. Six years after recommending this:

A related finding from this event is we need to do a better job of making highly-reliable multi-AZ deployments easy to design and operate. Some customers’ applications (or critical components of the application like the database) are deployed in only a single Availability Zone, while others have instances spread across Availability Zones but still have critical, single points of failure in a single Availability Zone. In cases like these, operational issues can negatively impact application availability when a robust multiAvailability Zone deployment would allow the application to continue without impact. We will look to provide customers with better tools to create multi-AZ applications that can support the loss of an entire Availability Zone without impacting application availability.

they realised they hadn't changed some of their crucial services to run in multiple availability zones.

We understand that the SHD provides important visibility to our customers during operational events and we have changed the SHD administration console to run across multiple AWS regions.

An orchestration tool such as Kubernetes or Docker Swarm is indeed invaluable when setting up and managing multi-zone, or even multi-cloud deployments. That was a great blog post, thanks for sharing it. It strengthens my belief in multi-cloud distributed environments to increase resilience and avoid common pitfalls such as vendor lock-in. If you happen to be interested in the ins and outs of setting up a multi-cloud environment in Docker Swarm, I have published an article on the Weave Net blog that describes the process: https://www.weave.works/blog/multi-cloud-big-data-processing-with-flink-docker-swarm-and-weave-plugin

Thanks again for the very interesting comments. Looking forward to reading your book!

That's interesting, I wonder if it's the same outage reported here: https://aws.amazon.com/message/65648/

Amazon does seem to recommend distributing your resources across different zones to increase fault tolerance. Following this same line of thought, distributing across clouds would add another level of resilience to the cluster.

Good to hear you cover Kubernetes clusters deployed to hybrid and multi-clouds. I am researching this topic at the moment and have added your book to my "to read" list

Welcome to the Ranch, Marko.

I am interested in container orchestration tools, and have recently been experimenting with multi-cloud setups using Docker Swarm and the Weave Net Docker plugin. I was wondering if you'd covered something like this in your book, i.e. setting up Kubernetes clusters with nodes distributed across different clouds. What are your thoughts on this?

Thank you very much and congratulations on your book publication!

Hi Andrew,

This looks like a very interesting book. Looking at the table of contents, I was wondering if you'd considered the use of a streaming approach to analyse not only real-time (or close to real-time) data, but also very large finite stored data. This seems to be the approach behind the Apache Beam project, founded by the guys at Google (I don't work for them, by the way, I am just a researcher). Basically, the idea is that you could use the same abstractions from streaming such as windowing to analyse very large, but finite, data. The conventional dichotomy between batch and stream thus ceases to exist, since all big data, finite or infinite, can be treated as stream.

Fascinating stuff, and it really expands the scope of streaming methods and techniques beyond near-real-time or streaming data.

Congratulations on the publication of your book, I have added it to my "to read" list!

public class Family { String name; public Family(String name) { this.name = name; } } public class Dog { static Family family = new Family("Canidae"); String breed; String colour; int size; public Dog(String breed, String colour, int size) { this.breed = breed; this.colour = colour; this.size = size; } public static void main (String[] args) { Dog myDog = new Dog("poodle", "black", 500); //myDog has-a family: System.out.println(myDog.family.name); //Canidae //This is the same as calling Dog.family.name. Because family is static, every Dog shares the same instance of Family. } }

This is a slightly different type of composition as every instance of Dog shares the same instance of Family. However, there is still a has-a relationship: every Dog has-a Family.

I get the same result as the book. The '-' never gets added to the String because of the post increment operator in the for loop.

Try running this:

import static java.lang.System.*; class _ { static public void main(String[] __A_V_) { String $ = ""; for (int x = 0; ++x < __A_V_.length; ) { $ += __A_V_[x]; out.println("index is: " + x + " and element is: " + __A_V_[x]); } out.println($); } }

Output:
index is: 1 and element is: A index is: 2 and element is: . A.

Jeanne Boyarsky wrote:You need to practice getting faster at all the questions including the long ones *before* going to take the real exam.

I agree, you need to practice answering the long questions fast before the exam. It's a skill in itself, and very important in this particular exam. If you read about 2/3 of a question, decide it's too long, then mark it for revision, you will have even less time to do it in the end. Assuming that you will start reading that question from the beginning again, you will have lost the time it took you to read it the first time around.

Plus, from my experience, a lot of the long ones are actually quick to answer. You just need to be strategic about it: read the question, read the answers, then and only then look at the code.

If you are new to Java, I suggest writing as much code as you can to test the new APIs you are learning. Don't take the book's words for granted: test everything. And make sure you test edge cases as well.

As for taking the actual exam, it takes practice going through complex questions and answering them quickly. Try to do as many mocks as you can, and make sure you time yourself while doing them, so you have an idea of what pace you should keep for the real exam. It's a skill in itself, and it takes practice.

I'm sure you'll do better next time, all you need to do is prepare for it carefully.