Using Spring HTTP Invoker

Spring provide features to integrate classes for remoting support using various technologies like Remote Method Invocation (RMI), Hessian, Burlap, JAX-WS,Java Messaging Service (JMS), Advanced Messaging Queuing Protocol (AMQP) and Spring HTTP Invoker.It is recommended that you must have bit of idea about proxy pattern as Spring remoting framework follow the Proxy software pattern. Here we will be looking into Spring HTTP Invoker only. 

Spring HTTP Invoker comes into picture when Spring recognizes the need of HTTP based client server communication and which uses java serialization because RMI  services uses java serialization but it difficult to work with across firewall and on the other side HTTP based services such as Hessian and Burlap work well across firewall but they use there proprietor serialization method not java serialization.  


Spring HTTP Invoker is a special remoting strategy which allows for Java serialization via HTTP, supporting any Java interface clients to communicate with Spring server using HTTP service without client knowledge of implementation. As it is working on HTTP service it will be easy to use it across network with firewall.
 

Fig.1. Spring HTTP Invoker Flow

Spring HTTP Invoker flow steps:-

• Client invoke the proxy's service method which is being handle by HttpInvokerProxyFactoryBean.
• The proxy convert the method call to HTTP remote call.
• The HTTP Service Adapter intercept to remote call and create HttpInvokerServiceExporter.
• It the forward the method call to Service. 

Fig. 2. Dispatcher Flow

Spring HTTP invoker remote service is simple and easy. Lets get into the implementation of Spring HTTP Invoker client server model using web container and without web container.

First we start where Spring HTTP Invoker server running in web container.

Step 1. Create interface for the client

Application.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. public interface Application {
4. String getGreeting(final String name);
5. }

Step 2. Create the service for client

ApplicationService.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. public class ApplicationService implements Application {
5. @Override
6. public String getGreeting(String name) {
7. return "Hi " + name + " !!";
8. }
10. }

Step 3. Create the web.xml

web.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xmlns="http://java.sun.com/xml/ns/javaee"
4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
5. id="WebApp_ID" version="3.0">
7. <display-name>Application</display-name>
9. <welcome-file-list>
10. <welcome-file>pages/index.jsp</welcome-file>
11. </welcome-file-list>
13. <servlet>
14. <servlet-name>Application</servlet-name>
15. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
16. <init-param>
17. <param-name>contextConfigLocation</param-name>
18. <param-value>/WEB-INF/WebAppContext/SpringServletContext.xml
19. </init-param>
20. <load-on-startup>1</load-on-startup>
21. </servlet>
23. <servlet-mapping>
24. <servlet-name>Application</servlet-name>
25. <url-pattern>*.http</url-pattern>
26. </servlet-mapping>
28. </web-app>

Step 4. Create the Spring Servlet Application context. 

This is where we exposing the beans as HTTP service. In case of web application request handler by DispatcherServlet then dispatches to HTTP invoker service. This service translate them into method call in Spring manages beans.  
Here applicationService is the service bean and /greeting.http is Spring HTTP service exporter bean.
      

WEB-INF\WebAppContext\SpringServletContext.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans:beans xmlns="http://www.springframework.org/schema/mvc"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:beans="http://www.springframework.org/schema/beans"
5. xmlns:context="http://www.springframework.org/schema/context"
6. xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
7. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
8. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
10. <annotation-driven />
11. <context:component-scan base-package="andy.blog.spring.remoting.httpinvoker.controller" />
12. <beans:bean
13. class="org.springframework.web.servlet.view.InternalResourceViewResolver">
14. <beans:property name="prefix" value="/pages/" />
15. <beans:property name="suffix" value=".jsp" />
16. </beans:bean>
18. <!-- Application Service -->
19. <beans:bean id="applicationService" class="andy.blog.spring.remoting.httpinvoker.service.ApplicationService" />
21. <!-- Exporter -->
22. <beans:bean name="/greeting.http"
23. class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">
24. <!-- Application Service reference -->
25. <beans:property name="service" ref="applicationService" />
26. <!-- Application interface -->
27. <beans:property name="serviceInterface" value="andy.blog.spring.remoting.httpinvoker.service.Application" />
28. </beans:bean>
30. </beans:beans>

Step 5. Application Context of Spring HTTP Invoker client. Here HttpInvokerProxyFactoryBean is a proxy factory for creating HTTP Invoker service proxies. serviceUrl is the service url where client send the HTTP request and it is create HTTP invoker service exporter object and invokes the actual service method call.

applicationContext.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans.xsd">
7. <bean id="applicationClient"
8. class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
9. <property name="serviceUrl"
10. value="http://localhost:9090/SpringHttpService/greeting.http" />
11. <property name="serviceInterface" value="andy.blog.spring.remoting.httpinvoker.service.Application" />
12. </bean>
14. </beans>

Step 6. To access service via HTTP create the Client.

ApplicationClient.java

1. package andy.blog.spring.remoting.httpinvoker.client;
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext;
5. import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;
7. import andy.blog.spring.remoting.httpinvoker.service.Application;
9. public class ApplicationClient {
11. public static void main(String...pram) {
12. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
13. HttpInvokerProxyFactoryBean httpInvokerProxyFactoryBean = context.getBean(HttpInvokerProxyFactoryBean.class);
14. Application application = (Application) httpInvokerProxyFactoryBean.getObject();
15. System.out.println("Start Application Client ");
16. System.out.println(application.getGreeting("Tom"));
17. System.out.println(application.getGreeting("Harry"));
18. System.out.println(application.getGreeting("James"));
19. System.out.println(application.getGreeting("Andy"));
20. System.out.println("End Application Client ");
21. }
23. }

Run the Spring HTTP Invoker server side into some web container and the run the client.

Start Application Client
Hi Tom !!
Hi Harry !!
Hi James !!
Hi Andy !!
End Application Client
 

Now we will see how to create Spring HTTP Invoker server running in non-web container and how to write a test case for that.
Repeat Step 1 create an interface for the client.

We will re-write the HTTP service method to distinguishes from above service method. Just changed the return message text.

ApplicationService.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. public class ApplicationService implements Application {
5. @Override
6. public String getGreeting(String name) {
7. return "Hi " + name + " !! This is non web service"; // message is changed
8. }
10. }

Simple HTTP server applicationContext.xml here application service & HTTP service exporter are same as above discussed but we here used org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter instead of HttpInvokerServiceExporter. Here
org.springframework.remoting.support.SimpleHttpServerFactoryBean is used to create simple HTTP Server based on the HTTP server that is included in Sun's JRE.

applicationContext.xml

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
5. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
6. xmlns:context="http://www.springframework.org/schema/context"
7. xmlns:util="http://www.springframework.org/schema/util">
9. <context:annotation-config />
11. <!-- Application Service -->
12. <bean name="applicationService"
13. class="andy.blog.spring.remoting.httpinvoker.service.ApplicationService" />
15. <!-- Exporter -->
16. <bean name="serviceExporter"
17. class="org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter">
18. <property name="serviceInterface"
19. value="andy.blog.spring.remoting.httpinvoker.service.Application" />
20. <property name="service" ref="applicationService" />
21. </bean>
23. <!-- Http Web Server -->
24. <bean id="httpServer"
25. class="org.springframework.remoting.support.SimpleHttpServerFactoryBean">
26. <property name="contexts">
27. <util:map>
28. <entry key="/SpringHttpService/greeting.http" value-ref="serviceExporter" />
29. </util:map>
30. </property>
31. <property name="port" value="9090" />
32. </bean>
34. <!-- For JUnit Test -->
35. <bean id="remotedApplicationService"
36. class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
37. <qualifier value="remoted" />
38. <property name="serviceUrl"
39. value="http://localhost:9090/SpringHttpService/greeting.http" />
40. <property name="serviceInterface"
41. value="andy.blog.spring.remoting.httpinvoker.service.Application" />
42. </bean>
43. </beans>

We have to create a simple HTTP server using Sun's package. This is required to to run the HTTP server for our client application.

ApplicationServer.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext;
6. import com.sun.net.httpserver.HttpServer;
7. public class ApplicationServer {
9. public static void main(String[] args) {
10. ApplicationContext context = new ClassPathXmlApplicationContext("/applicatonContext.xml");
11. HttpServer appServer = (HttpServer) context.getBean("httpServer");
12. }
14. }

Test case to make sure our HTTP invoker service work's fine.

ApplicationServiceTest.java

1. package andy.blog.spring.remoting.httpinvoker.service;
3. import static org.junit.Assert.assertEquals;
4. import static org.junit.Assert.assertTrue;
6. import org.junit.Test;
7. import org.junit.runner.RunWith;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.beans.factory.annotation.Qualifier;
10. import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;
11. import org.springframework.test.context.ContextConfiguration;
12. import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
13. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
15. @RunWith(SpringJUnit4ClassRunner.class)
16. @ContextConfiguration(inheritLocations = true, locations = { "/applicatonContext.xml" })
17. public class ApplicationServiceTest extends AbstractJUnit4SpringContextTests {
19. @Autowired(required = true)
20. @Qualifier("remoted")
21. private Application application;
23. @Test
24. public void getGreetingTestUsingConfiguredClient() throws Exception {
25. String greeting = application.getGreeting("Tom");
26. assertEquals("Hi Tom !! This is non web service", greeting);
27. System.out.println(greeting);
28. assertTrue("Should not be the implementation", !application.getClass().equals(ApplicationService.class));
29. }
31. @Test
32. public void getGreetingTestManually() throws Exception {
33. HttpInvokerProxyFactoryBean proxy = new HttpInvokerProxyFactoryBean();
34. proxy.setServiceInterface(Application.class);
35. proxy.setServiceUrl("http://localhost:9090/SpringHttpService/greeting.http");
36. proxy.afterPropertiesSet();
37. Application application = (Application) proxy.getObject();
38. String greeting = application.getGreeting("tester");
39. assertEquals("Hi tester !! This is non web service", greeting);
40. System.out.println(greeting);
41. assertTrue("Should not be the implementation", !application.getClass().equals(ApplicationService.class));
42. }
43. }

If you run the above test or above client you get below output.
Hi tester !! This is non web service
Hi Tom !! This is non web service

Well Spring HTTP Invoker is quite easy to implement you just need a reason to run two application on different JVMs.  

My weekend trip to Purulia, Chandil Dam, Jayda Temple, Dalma Wildlife Sanctuary and Jamshedpur

My last week end trip (25th July 2014 to 29th July 2014) was at Purulia, Chandil Dam, Dalma Wildlife Sanctuary and  Jamshedpur. 

Purulia

Purulia is also known as "Manbhum" located in West Bengal, India. The  beauty of natural forest, variety of flora and fauna, scattered hills and falls, rivers and streams make this place eye-catching to the nature lovers and these makes ideal place expeditions and enjoyment.

There are many temples in and around Purulia which are archeological asset of this district. Some of these temples are below to 17th century. 

Ayodhya hills is a part of the Dalma mountain range. It is spread accross on the boundary between Purulia district and Jharkhand. Gorshabru, the highest peak of the Ayodhya Hills is situated at a magnificent 2800(+) feet is deep inside the jungle there a forest. There are many watch towers in this jungle, have close watch on road side pillars which have watch tower, fall name direction and other information. There are several dams in and around Ayodhya hills one of them is Purulia Pump Storage Project (or P.P.S.P). Purulia Pump Storage Project is one of the largest stagnant water hydrel project of India, capacity of which is 900 m.w. The project consists of two dam- upper dam & lower dam. Scenic beauty upper dam is very nice to watch.

I heard a folklore from local villager that Ram and Sita had come to Ayodhya Hills and stayed during their exile. During the full moon day in Baisakh (first month in the Bangla Calendar) every year tribal's of nearby areas come and join in the game of hunting wild animals only for one day in year they are allowed to hunt.

Purulia is easily accessible by road and by train from Kolkata, from  Howrah/Santragachi 12827/Howrah - Purulia Superfast Express, 12883/Rupashi Bangla Express, 12152/Samarsata SF Express, 58011/Howrah - Chakradharpur Passenger. It is 295 Km away from Kolkata towards west and 119 Km from Ranchi towards east. The National Highway – 32 and National Highway – 60A passes through the District. SBSTC, CSTC, NBSTC buses and many privately operated buses ply between Kolkata to Purulia.

 

P.P.S.P upper dam

   

Information

Rough Map

View from watch tower

Chandil Dam,Jayda Temple, Dalma Wildlife Sanctuary and  Jamshedpur all places are in Jharkhand ("The Land of Forest")  eastern India state, which have large portion of forest and minerals resources of India. 

Chandil Dam is standing on the Subarnarekha River is 220 meter in height and the height of its water level is 190 meter. This dam is most visited place in Jharkhand. Other that scenic beauty you can enjoy boating. There is parking fee at Chandil Dam for bus/truck Rs.100/-,for TATA Winger Rs.30/-,for car Rs. 20/-, for two wheeler Rs.10/-. Seriously speaking why they have special charge for "TATA Winger" I don't know.

Chandil Dam

Boating Platform

Subarnarekha River

Boating

The nearby Jayda Temple dedicated to Lord Shiva is another popular attraction nearby. A huge fair is held every year at the site on the eve of Makar Sankranti.Situated on the way to Ranchi-Tata road.

Jayda Temple

Jayda Temple history

Dalma Wildlife Sanctuary is a much larger area starting from area of Subarnarekha River and adjoining Purulia District of West Bengal, this wildlife sanctuary with an area of 193.22 Sq. Km. on the National Highway No. 33 near Jamshedpur has undulating terrain with high hillocks (Max. 984 M MSL). This wildlife sanctuary home for Elephant,Leopard, Barking Deer, Mouse Deer, Sloth Bear, Monkey, Giant Squirrel. The sanctuary is very much favored by the Elephants due to availability of water even during summer.At top there is Lord Hanuman Mandir and cave of Lord Shiva. The vast forest land is ideal place spot for trekking expeditions. There are many trekking trails from mild to medium trekking. There is 20 KM drive from foot to top of hill in the forest. There are watch tower from there you can get a view of Jamshedpur City. There are charges to get into the forest.
   

Forest Road

View Of Jamshedpur City from Dalma Forest watch tower

Jamshedpur 

Jamshedpur is the first planned industrial city of India, founded by Jamshedji Nusserwanji Tata. There many interesting place in Jamshedpur but I manage to visit "TATA Steel Zoological Park" and "Jubilee Park (Jayanti Sarovar)" which is one of the biggest park in India apart from this there are 1000 varieties of roses in this garden and in lake you can do boating.

 

Jayanti Sarovar

I went there from Purulia by National Highway-32 which pass through Chandil and Dalma Wildlife Sanctuary from West Bengal to National Highway-33 which leading to Ranchi and Jamshedpur.

OCJP 7 book review

Book Title: Oracle Certified Professional Java SE 7 Programmer Exams 1Z0-804 and 1Z0-805

Author's Names: S G Ganesh & Tushar Sharma

Type of Book/Genre: OCPJP 7 Certification

Description/Brief Summary: This book is for OCPJP 7 certification.

Review:

If you are studying for OCPJP 7 examination, then I find this book is very useful. You could be a professional who wants to brush-up on Java APIs, you could be a trainer for Core Java, or you could be someone who just want to pass the exam. This book is very well-organized and it covers all the topics for OCPJP 7 in required depth.

The first chapter contains OCPJP 7 examination FAQs that provides OCPJP 7 certification overview, kinds of questions that come in this certification examination, details about how to prepare for it and the most interesting things as well as very useful information for readers who is going to give this kind of certification examination for the first time, that is how to register, what to do on the examination day, etc.

The second chapter contains a pre-test; this chapter will be useful to check your current-level of knowledge and find your weakness before you start. A new learner can skip this chapter as this chapter required beginners/intermediate knowledge in Java.

Rest of the twelve chapters covers all the topics required for OCPJP 7 with examples to explain the APIs and tricks, this chapters end with a test named "Question Time!" to check reader's learning and most important thing there is a summary section at the end of each chapter which is a great help for quick recap. Apart from this there is a "Points to Remember" section to which highlight the tricky parts covered in that section.

At the end there are two OCPJP 7 mock exams which will help reader for final preparation and check actual preparedness for the examination.

I really enjoyed reading it. I recommend this book for OCPJP 7 certification and as a Core Java book.

NoSQL Overview

Today's internet age data nature, size and query response changes dynamically due to huge user load resulting into data start growing unmanageably.

Wal-Mart: 1 million transactions per hour

Twitter: 250 million tweets a day

Facebook: 1 billion messages a day

RDMS are not design to handle this volume of data since they are generally design to scale on single server, so user need to buy a bigger machine to meet this requirement and it will add huge input cost.  

Now this data is accessed from mobile devices to desktop. (Data is distributed & urgent)

$300 billion potential annual value to US health care. (Data is valued)

To meet the need of  scalability, performance and consistency required in this web era NoSQL databases are schema free, easy replication support, sharding, instead of ACID**  it follow BASE**, following CAP** theorem etc.

** ACID is Atomicity, Consistency, Isolation, Durability. BASE is Basically Available, Soft State, and Eventually Consistent. CAP is Consistency , Availability , Partition tolerance

Schema free: There is no predefined schema for NoSQL databases.

Easy Replication Support: NoSQL databases employ asynchronous replication, which allows write to complete more quickly since they don’t depend on extra network traffic.

Horizontal Scaling: NoSQL databases split tables across different server, but with only instance of the same data.

Sharding: NoSQL can perform sharding. In which records (rows) are distributed across many database server.

BASE instead of ACID: NoSQL databases emphasis on performance and availability.

Basic Availability: NoSQL use replication to reduce the likelihood of data unavailability and use sharding, or partitioning the among many different storage server, to make any remaining failure partial. The result is a system that is always available, even if subsets of the data become unavailable for short period of time.

Soft State: NoSQL systems allow data to be inconsistent and relegate designing around such inconsistencies to application developers.

Eventual Consistency: Although applications must deal with instantaneous consistency, NoSQL systems ensure that at some future point in time the data assumes a consistent state. In NoSQL it guarantees consistency only at some un-define future time.

Here is one important theorem of distributed computer system CAP theorem or Brewer’s theorem, which is followed by NoSQL databases.

Consistency: All database clients see the same data, even with concurrent updates.

Availability: All database clients are able to access some version of the data.

Partition Tolerance: The database can be split over multiple servers & at any moment data must be available even if any node(s) / communication link(s) fails.

NoSQL database come in many form to meet application requirement like key-value store, column family store, document store and graph store are the major forms.

Key-Values Store main idea is the existence of a hash table where there is a unique key and a pointer to a particular item of data. These mappings are usually accompanied by cache mechanisms to maximize performance.

Column Family Store was created to store and process very large amounts of data distributed over many machines. There are still keys but they point to multiple columns.

Document Store model is basically versioned documents that are collections of other key-value collections. The semi-structured documents are stored in formats like XML, JSON (JavaScript Object Notation), YAML (Yet Another Markup Language)& BSON(Binary JSON).

Graph Store is built with nodes, relationships between notes and the properties of nodes. Instead of tables of rows and columns and the rigid structure of SQL, a flexible graph model is used which can scale across many machines.

TEST DRIVEN DEVELOPMENT = TEST FIRST DEVELOPMENT + REFACTORING

TEST DRIVEN DEVELOPMENT = TEST FIRST DEVELOPMENT + REFACTORING

Test driven development (TDD) is a software development process, in which developer write test first then start development in small incremental manner to pass this test and refactoring the code whenever required.

Now days customer expect from their software developer to write code with almost zero bug without compromising deadlines. To achieve this TDD is one of the software development processes which help in bug reduction, since this process start with testing and advocate testing after any refactoring happens which make sure that software work at least in tested scenarios if used correctly. TDD can change overall design of code for better if it is used effectively.

 

Usually developers develop the code first then write test cases. But in TDD process developer write a unit test then run that test and that test fail since developer didn’t written anything yet, now developer write code to pass that test and developer do required refactoring whenever required.

There are two type of TDD:

1. Developer TDD: Process is same as TDD.
2. Acceptance TDD / Behavior Driven Development (BDD): In BDD acceptance test are written then coding to pass that acceptance test.

 

How to implement TDD?

Think how new code will be implemented or refactoring of existing code happen.

Example: - Fibonacci number series 0,1,1,2,3,5,8…

Write just enough stub code, so developer can compile.   

Example:-

public int fibonacci(int x) {

return 0;

}

Add a test to for stub code.

Example:-

^{public void testFibonacci_whenX_isOne() {}

^{assertEquals(0, Fibonacci(1));}

^}

Write a code to pass the test.

Example:-

public int fibonacci(int x) {

if(x == 0) return 0;

if(x == 1) return 1;

return 0;

}

Again run the test.

Add more tests for incremental development and refactoring code whenever possible.

Note: - In pair programming TDD is very effective. Since pair developer helps each other to keep in track.

TDD and Legacy code

The challenge is working with legacy code which didn’t have any test case. In order to introduce test into legacy code developer have to isolate the unit and refactoring the code, so that it can be tested.

Advantage of TDD

1. TDD acts as a constant feedback that each unit is still working.
2. TDD helps to isolate the problems in code.
3. After the test pass and developer refactoring the code to remove duplicate code then again this test ensue development complete.
4. Since TDD required very detail level of requirement. It forces developer to understand the requirement well before actual coding.
5. The test suite acts as a regression safety net on bugs: If a bug is found, the developer should create a test to reveal the bug and then modify the production code so that the bug goes away and all other tests still pass. On each successive test run, all previous bug fixes are verified.

Disadvantage of TDD 

1. TDD didn’t test with other resources like database, JMS etc. 
2. If TDD is not used carefully, it can add cost and complexity to the project.
3. TDD is highly reliant on refactoring and programming skill.
4. It is difficult to detect deeper faults in code.

Even after enormous test case can create problem just like when you add this test into build for continuous integration it might take too long to complete. If developer use TDD properly, then code produced from this process is testable, well designed & developers find that they will be spending less time in debugging. But still developer make mistakes but it can be catch too early.