DEV Community: Saumya Agnihotri

Introduction to Servlets

Saumya Agnihotri — Sat, 11 Sep 2021 19:02:33 +0000

While surfing any website on the internet, for any page in it there are two things that happens, request and response between the client and server. Client sends a request to retrieve any page and response comes from the server.

There are basically two types of pages - static and dynamic. Dynamic pages are those pages which are created during run time.

Web containers

So now to understand where servlets fits in this picture, we need to understand something called web containers which are nothing but helper applications which are used to generate these dynamic pages. These helper functions contains servlets for the same purpose. Apache Tomcat is one of the examples for web containers.

Servlets

Now what exactly this servlet does and what it is exactly? It's nothing but a java file which can take the request from the client on the internet and it can process that request and it can provide you a response in the form of an HTML page. It's a normal class that extends HttpServlets

Deployment Descriptor

Now how does this web container will know which servlet is suitable for handling any incoming request. Well, for that we have web.xml files which are also know as deployment descriptor. Here you mention for which request which servlet should be called.

How to keep your local changes while pulling the code

Saumya Agnihotri — Tue, 24 Nov 2020 16:11:58 +0000

If you are working on a project in a team and you have used GitHub as your version control system then you might have come across a situation where you're working on some feature but the work hasn't finished yet and there are some update from other member and now you need to pull the code again from remote repository.

Now a problem arises here, while you're pulling the code your changes (work in progress) will be overridden and you will lose your code that wasn't committed. So in such scenarios, you can use a git command known as git stash.

What is Git Stash?

Git stash will solve the problem faced in the above scenario. You can keep your changes similar to keeping a draft and then after pulling the remote repo code you can go back to draft version and apply the changes again.

So the usual flow will go like this :

You are working on some unfinished feature and you need to save this (draft)

          git stash
           or 
          git stash save "feature X"

Now you pull the code
```
          git pull origin master
```
Restore the work you were doing for feature X using below command
```
          git stash apply
```

That's it. You are done ✅

For learning more about git stash you can refer to these resources :

Links -

Levels and Methods In Software Testing

Saumya Agnihotri — Sun, 01 Nov 2020 06:11:30 +0000

Testing Software is a very crucial phase of the whole software development cycle. It is generally done in 4 levels :

Unit Testing
Integration Testing
System Testing
Acceptance Testing

Let's discuss each one of them briefly.

Unit Testing -

First level of testing which is done right after coding any module by the developer. It ensures that a module is working fine independently.

Integration Testing -

Integration Testing is done after unit testing where it is checked whether all modules are working as intended when they are integrated. But sometimes we don't have all the modules completed and integration testing keeps on happening along with the development. So now the question arises what do we do in that case? Well, for that case we have dummy programs which are known as stubs and drivers. Stubs are the called function and drivers are the calling function.

System Testing -

System Testing is also called an end to end testing. It is performed to ensure whether the integrated code is working fine with the perspective of the user.

Acceptance Testing -

Acceptance Testing is the final stage of the whole testing process and it is done by the end-user where it is ensured that the software is ready for production.

Now let's look at the various methods of testing.

Black box testing
White box testing
Gray box testing

Black box testing -

In this, you don't need to have any prior knowledge about the internal structure or implementation of the system. It can be applied to every level of testing (Unit, Integration, System & Acceptance). It is very useful in enhancing the end-user experience.

White box testing -

For white box testing, the tester needs to know about the internal structure of the system being tested. It can be done at unit, integration & system levels of testing.

Simply put, in white box testing we test the actual code while in case of the black box testing, we test the software from a user's point of view.

Gray box testing -

Gray box testing is also known as translucent testing. In this, only limited knowledge about the internal structure is known. The objective here is to find out the defects resulted from the bad structure of code.