Observability Done Right: Best Practices and Anti-Patterns for Effective System Monitoring

-
Image
  WHAT Observability is a concept that refers to the ability to gain insights into the behavior and performance of complex systems. In the context of software engineering, observability involves the collection, analysis, and visualization of data from software applications, infrastructure, and other components of a system. In the animal kingdom, observability plays a critical role in survival, allowing animals to monitor their surroundings, detect threats, and find food. Dolphins use echolocation to observe their surroundings. They emit high-frequency sounds that bounce off objects, allowing them to create a 3D map of their environment. Thanks for reading Knowledge Cafe! Subscribe for free to receive new posts and support my work. Subscribed WHY In today's era, architectures are becoming increasingly large, complex, and fast-paced due to the faster development and deployment of software by distributed teams with the help of DevOps, continuous delivery, and agile development methodo...

Map sorting based on Values

-

Map sorting based on Values (instead of keys)


These days one of the very popular interview question is regarding having Map type collection with sorting based on values (Map is key->value pair). TreeMap can give you Key based sorting.

Use case would be We have Student object (with student name and roll number properties) and we have Result object (having int result property). We have to use Student as key and Result as value in our Map but requirement is Map should be having sorting order based on values(result).

I have tried to solve this using below program, Please suggest if there is better way or this can be improved.

Result.java

package collection;
public class Result implements Comparable{
 private int marks;
 public int getMarks() {
  return marks;
 }
 public void setMarks(int marks) {
  this.marks = marks;
 }
 @Override
 public int hashCode() {
  final int prime = 31;
  int result = 1;
  result = prime * result + marks;
  return result;
 }
 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  Result other = (Result) obj;
  if (marks != other.marks)
   return false;
  return true;
 }
 @Override
 public int compareTo(Object arg0) {
  if(this.getMarks()> ((Result)arg0).getMarks())
  return 1;
  else if(this.getMarks()< ((Result)arg0).getMarks())
   return -1;
  else return 0;
 }

 Result(int lmarks){
  this.marks = lmarks;
 }
 @Override
 public String toString() {
  return "Result [marks=" + marks + "]";
 }

}

 Student.java


package collection;
public class Student{
 private int id;
 private String name;
//Getters and setters 
@Override
 public String toString() {
  return "Student [id=" + id + ", name=" + name + "]";
 }
public Student(int id, String name){
this.id=id;
this.name=name;
}

 MapSortingDemo.java


package collection;
import java.util.*;
import java.util.Map.Entry;
public class MapSortingDemo {
 public static void main(String[] args) {
  Student s1 = new Student(10,"Amit");
  Student s2 = new Student(15,"AMMM");
  Student s3 = new Student(5,"MMM");

  Result r1 = new Result(65);
  Result r2 = new Result(75);
  Result r3 = new Result(55);

  Map<Student, Result> m = new HashMap<Student, Result>();
  m.put(s1, r1);
  m.put(s2, r2);
  m.put(s3, r3);
  Map <Student, Result> sortedonValues = sortByComparator(m);

  System.out.println(sortedonValues);
 }
 @SuppressWarnings("unchecked")
 private static Map<Student,Result> sortByComparator(Map<Student, Result> unsortMap) {

  List <Student>list = new LinkedList(unsortMap.entrySet());

  // sort list based on comparator
  Collections.sort(list, new Comparator() {
   @SuppressWarnings("rawtypes")
   public int compare(Object o1, Object o2) {
    return ((Comparable) ((Map.Entry) (o1)).getValue())
                                       .compareTo(((Map.Entry) (o2)).getValue());
   }
  });

  // put sorted list into map again
                //LinkedHashMap make sure order in which keys were inserted
  Map sortedMap = new LinkedHashMap();
  for (Iterator it = list.iterator(); it.hasNext();) {
   Map.Entry entry = (Map.Entry) it.next();
   sortedMap.put(entry.getKey(), entry.getValue());
  }
  return sortedMap;
 }
}

 Output:


{Student [id=5, name=MMM]=Result [marks=55], Student [id=10, name=Amit]=Result [marks=65], Student [id=15, name=AMMM]=Result [marks=75]}

Suggestion and alternate methods welcome. Happy coding.


Popular posts from this blog

Chain of responsibility using Spring @Autowired List

-
Image
There is a way in Spring 3.1 to auto populate a typed List which is very handy when you want to push a bit the decoupling and the cleaning in your code. To show you how it works, I will implement a simple chain of responsibility that will take care of printing some greetings for a passed User. Let start from the (only) domain class we have, the User: package in.softcaretech.springchain; public class User { private final String name; private final char gender; public User(String name, char gender) { super(); this.name = name; this.gender = gender; } public String getName() { return name; } public char getGender() { return gender; } } Then we create an interface that defines the type for our command objects to be used in our chain: package in.softcaretech.springchain; public interface Printer { void print(User user); } This is the generic class (the template) for a Printer implementation. The  org.springframework.core.Ordered  is used to tell the AnnotationAwareOrderCo...
Explore more »

Iterate Through a HashMap

-
The  HashMap  is one of the most useful data structures in the Java programming language. Once you have a HashMap filled with data, you may want to iterate through its keys and values. Below are three different ways to iterate through a Java HashMap. Sample HashMap Here is our sample HashMap. The key is an Integer and the value is a String: HashMap <Integer, String> hm = new HashMap<Integer, String>(); hm.put(0, "zero"); hm.put(1, "one"); hm.put(2, "two"); In the above Java code, we first declare the HashMap. Then we add the values "zero", "one" and "two" with the keys 0, 1 and 2 respectively. Now that the HashMap has data, we can try to iterate over the keys and values. Iteration Example 1 for (int i=0; i < hm.size(); i++) { Integer key = hm.keySet().toArray()[i]; String val = hm.values().toArray()[i]; System.out.println("key,val: " + key + "," + val); } In this example, we use a  for  loop ...
Explore more »

Under the Hood: Understanding the Gossip Protocol in Apache Cassandra

-
Image
  Gossip Protocol Apache Cassandra is a highly scalable and distributed NoSQL database management system designed to handle large amounts of data across many commodity servers. It was developed at Facebook and later became an Apache Software Foundation project. Cassandra offers a number of key features, including: Linear scalability, high availability, Predictive data consistency, flexible data modeling and high performance. What is Gossip Protocol The Gossip protocol is a key component of the Apache Cassandra distributed database system. It is used for node communication and failure detection within the cluster. The following is how it works: Each node in the Cassandra cluster maintains a list of all other nodes in the cluster and information about their status. The Gossip protocol operates in rounds, where each node sends its state information to a randomly selected set of other nodes. The receiving nodes update their state information based on the information received from their...
Explore more »