diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..f06d999
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/.gitignore b/.gitignore
index 6143e53..719dd1d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,9 +1,10 @@
# Compiled class file
+.idea/*
*.class
# Log file
*.log
-
+*.iws
# BlueJ files
*.ctxt
diff --git a/.project b/.project
new file mode 100644
index 0000000..a33e785
--- /dev/null
+++ b/.project
@@ -0,0 +1,15 @@
+
+
+ DesignPatternsJava9
+
+
+
+
+ org.eclipse.jdt.core.javabuilder
+
+
+
+
+ org.eclipse.jdt.core.javanature
+
+
diff --git a/DesignPatternsJava9.eml b/DesignPatternsJava9.eml
new file mode 100644
index 0000000..82e1875
--- /dev/null
+++ b/DesignPatternsJava9.eml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
diff --git a/DesignPatternsJava9.iml b/DesignPatternsJava9.iml
new file mode 100644
index 0000000..5a95221
--- /dev/null
+++ b/DesignPatternsJava9.iml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/README.md b/README.md
index 9e0034c..d23c5ad 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,27 @@
-# DesignPatternsJava9
-This repo consists Gang of Four Design patterns code on Java 9. Each branch in the repository has code of 1 design pattern. Switch repository to try out different design patterns.
+# What is Cyclomatic Complexity?
+Cyclomatic complexity is a source code complexity measurement that is being correlated to a number of coding errors. It is calculated by developing a Control Flow Graph of the code that measures the number of linearly-independent paths through a program module.
+
+Lower the Program's cyclomatic complexity, lower the risk to modify and easier to understand.
+Cyclomatic complexity = E - N + 2*P
+where,
+* E = number of edges in the flow graph.
+* N = number of nodes in the flow graph.
+* P = number of nodes that have exit points
+
+
+If the decision points are more, then complexity of the program is more. If program has high complexity number, then probability of error is high with increased time for maintenance and trouble shoot.
+#### Try to write linear code, which means wrap logic in reusable methods and use them.
+
+### Learn Design Patterns with Java by Aseem Jain
+This repository contains working project code used in video Course by Packt Publication with title "Learn Design Patterns with Java " authored by "Aseem Jain".
+
+### Course link:
+https://www.packtpub.com/application-development/learn-design-patterns-java-9-video
+
+###  Profile: http://in.linkedin.com/in/premaseem
+
+### Authors blog on design patterns:
+https://premaseem.wordpress.com/category/computers/design-patterns/
+
+### Software Design pattern community face book page:
+https://www.facebook.com/DesignPatternGuru/
diff --git a/src/CyclomatricComplexity.java b/src/CyclomatricComplexity.java
new file mode 100644
index 0000000..861c192
--- /dev/null
+++ b/src/CyclomatricComplexity.java
@@ -0,0 +1,53 @@
+/*
+@author: Aseem Jain
+@title: Design Patterns with Java 9
+@link: https://premaseem.wordpress.com/category/computers/design-patterns/
+*/
+public class CyclomatricComplexity {
+
+ /*
+ Problem Statement: Need to print biggest number from given numbers
+ */
+
+ public static void main (String[] args) {
+
+ Integer a=7,b=4,c=10,d=18;
+
+ if (a > b) {
+ if(a > c){
+ if (a >d){
+ System.out.println(a+ " is biggest");
+ }
+ }
+ }
+
+ if (b > c) {
+ if(b > d){
+ if (b >a){
+ System.out.println(b+ " is biggest");
+ }
+ }
+ }
+
+ if (c > b) {
+ if(c > a){
+ if (c >d){
+ System.out.println(c+" is biggest");
+ }
+ }
+ }
+
+ if (d > b) {
+ if(d > c){
+ if (d >a){
+ System.out.println(d+" is biggest");
+ }
+ }
+ }
+ }
+}
+
+// Take Away:
+// If the decision points are more, then complexity of the program is more.
+// If program has high complexity number, then probability of error is high
+// with increased time for maintenance and trouble shoot.
\ No newline at end of file
diff --git a/src/CyclomatricSimplicity.java b/src/CyclomatricSimplicity.java
new file mode 100644
index 0000000..f5b659c
--- /dev/null
+++ b/src/CyclomatricSimplicity.java
@@ -0,0 +1,35 @@
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/*
+@author: Aseem Jain
+@title: Design Patterns with Java 9
+@link: https://premaseem.wordpress.com/category/computers/design-patterns/
+*/
+public class CyclomatricSimplicity {
+
+ /*
+ Problem Statement: Need to print biggest number from given numbers
+ */
+
+ public static void main (String[] args) {
+
+ Integer a=7,b=4,c=10,d=18;
+ // Event when we need to modify parameter, things can be done
+ // with minimal code changes
+
+ PrintBiggestNumber(a,b,c,d);
+ }
+
+ private static void PrintBiggestNumber (Integer... numbers) {
+ System.out.println();
+ List list = Arrays.asList(numbers);
+ Comparable max = Collections.max(list);
+ System.out.println(max + " is biggest (KISS)");
+ }
+}
+
+// Take Away:
+// KISS - Keep it simple stupid.
+// Design clean dry less code which can absorb changes.