I woke up this morning, brushed my teeth, had breakfast, and then opened my laptop to attend my company training session. I was kind of frustrated with all the training and wanted to start with my job already. But here I was, stuck in the present.

Isn’t this familiar? Although this was an anecdote from my life, experiences like these are not out of the common. But have you ever wondered why people from so many different backgrounds, with different interests, hobbies and lifestyles undergo similar experiences? Can we say that we have such experiences because we are human beings? Are the feelings that we have hardwired into our biology?

I was always very much interested in studying evolution. And not only biological evolution, but also the evolution of societies, cultures, music, and science. One of my striking observations is that even though these belong to different academic fields, the basics of evolution remain the same. To understand evolution we need to understand a fundamental property that our universe exhibits — Emergence.

Emergence is the property by virtue of which simple small parts add up to create something too complex, and this complex structure would have properties that can only be formed by the interaction of these small parts. Our human body itself is one of the best examples of emergence. Our cells are not that complex structures (although they are if we look further into the molecular structure of a cell), but together they make up organs that can carry out complex tasks, and these organs coordinate with each other to give us life. Let’s take another example, a Corporate Organization. The organization is made of individuals who work collectively to create value. For example, a software engineer at Amazon would write some code, a quality assurance engineer would check for its credibility, and a marketing professional would advertise the service.

However, this gives rise to a question. We are made out of cells, and our body replaces all of its cells every 7 to 10 years. In the very same way, employees who constitute a company may change over the years. How can something stay the same even when all of its constituent elements have been changed? To understand this, let us take a simple example. You bought a new laptop, and now you want to take all your data from your previous laptop and store it on the new one. For simplicity, we will assume that both these laptops have the same operating system. Once the cloning process is complete, the constituent parts changed, but the programs and the software that you installed remained the same. Same data or information, but different underlying machinery.

Can we draw a parallel? A company is an independent entity and it exists in the market (or in the world) all by itself. People who constitute the company are primarily focused on their sustenance, and when each person works together for their sustenance, they ensure the sustenance of the company. In the same way, each cell in our body primarily has only one objective — to pass on their genetic material, and together when all the cells work for it, they ensure that the body functions optimally. The common thing between our body and a Corporate Company is that they are both information. There is nothing tangible. We cannot answer who we are by only considering tangible units like organs or cells. We are the outcome of the information that has been created from the quintillions of interactions that occur between our cells. Some of these interactions are impacted by the external world — demographics, economic class, status quo, experiences, and learnings.

Evolution is very much like emergence. One might even argue that evolution and emergence are synonymous. Evolution happens when small changes in a piece of information add up to create a totally different entity. In terms of biology, the cumulative effect of differences in the genetic material of a species can result in the formation of a new species. If we talk about our societies, small changes in the lifestyles of people add up and result in big revolutions. For example, the poor economic policies of France, weakened by the seven years of war and the American war of independence, the rising inequality between the bourgeoisie and the proletariats, and the rise of the concept of liberty and the constitutional governance gave rise to the French revolution, which created a worldwide movement towards the democratic form of governance.

We must understand that the way we are made out of the emerging properties of our cells, our society is made up of the emerging properties of our individual interactions with each other. We are the cells of our society. At an individual level, we are self-sustaining, smart, and calculative. But looking down from a societal level, we are small dumb parts of an abstract whole. We are not independent of each other. Everyone’s decision has an impact on every other in the society, no matter how minuscule that might be. And that might be the reason why we undergo similar experiences. Maybe there is something like a universal human experience, after all!

Thinking is also a very basic human experience. We all think, about something at every moment. But do you also think why everything is the way they are? Do you wonder if you knew all the secrets of this universe? Tell me in the comments section.

It was college after almost a week. In the last semester, you do not have a lot of classes, and the competence between students and the overall essence and spark of being in a class is at its minimum. It feels to me as if this is all life is now, monotonous, boring, and with no enthusiasm. But this wasn’t always the case, and this thought in itself concerns me a lot.

Back in my school days, and during the early semesters of college, life was bliss. I used to be enthusiastic, and full of energy. I wonder what has changed. Or if I went through a trauma and don’t know about it. Or maybe it’s just a phase that every person has to go through. Even possible, this feeling is cyclic, but as soon as it wears down, we forget about it.

We had three classes today from 10 a.m. to 3 p.m. with two hours in between with no classes at all. What a bummer it is to be alone for two hours under the scorching sun. The last class was Quality Issues in Engineering, which is the hardest subject for me this semester. I am dope at mathematics and analytical thinking, and this subject is basically a combination of the two.

Today, our professor was showing us the answer sheets from our exam the previous week. In our college, we have three exams called, T1, T2, and T3. T1 and T2 are like the internals, and T3 is like the externals. We need a total of thirty percent from all these exams combined to pass in that subject. Imagine how hard it must have been for me to explain this to my friends from other colleges.

I got twelve marks out of twenty, which is like sixty percent. I was so happy. I texted my boyfriend that very moment. It was as if I achieved something so unimaginably big (I still feel like that). But then this memory struck me so hard, that this kind of feeling wasn’t always the case. Getting twelve on twenty would be such a disappointment just two and a half years back.

I was quite above average in academics until my class twelfth. So getting sixty percent would be a great disappointment. But I remember that it wasn’t for everyone. When I was in tenth, there was this girl in our class who was not brilliant in academics. In one of our exams, she got some marks that wouldn’t satisfy me, but for her, it was such an achievement. And I could feel that today. I am not saying that I couldn’t understand her then. But there’s a difference between understanding and being in someone’s boots.

But this feeling today isn’t the first time. I have gotten low marks so many times now, that maybe now it doesn’t affect me at all. But I see people around me sobbing over their marks and even begging for increments whenever a teacher or a professor shows us our answer sheets. And more often than not, they are sobbing over something that is already too much. Why can’t people just be satisfied with what they get? Sometimes there can be errors in correcting a paper, but not every time, and not with everybody at the same time.

Although it might seem like a poorer version of me, I am grateful to have evolved like this. Because the world is not a pen and a paper exam, so worrying about marks or appreciation is not worthwhile. I believe that it is only important that I understand the concept and can visualize it in a real-world scenario. What do you think about this? When you look back at your life, how much difference can you see in yourself? Let me know in the comments below.

A lot of humankind’s tedious and monotonous workload has been relieved by the use of machines. Machines can be designed and made to work on a particular task, with high efficiency. The percentage of companies that have completely automated at least one function has grown from 29% in 2018 to 31% in 2020.

One of the uses of automation is in software testing utilities. Companies that create software need to check for bugs. Automation Testing is a technique that uses automated testing software to execute test case suites. Selenium is a popular open-source automation software, that lets you automate web browsers. It provides a single interface for writing scripts in many programming languages, like Ruby, Python, Java, Node.js, PHP, C#, and others.

But before we can dwell deep into programming a Google form automation software, we need to understand certain web basics.

Inspect a webpage

Open any random google form, then right-click anywhere on the page, and select inspect. This can be done on any webpage. You can try on this right now, on this page itself if you’re reading this blog on a PC or a laptop. Doing this opens up the background details of what is happening on that page.

HTML element identifiers

For any web application, identifying the HTML elements on a page is crucial for its working. HTML elements contain certain attributes that provide additional information about them. Some of these attributes help us provide identification to an HTML element. For example, a certain element on a webpage may belong to a certain class, or it may have a name or an ID.

<div>
 <p id=”para01" name=”description” class=”paragraph”>
  This is a paragraph tag.
 </p>
</div>

Selenium requires some form of identity to access a tag on a webpage. To find these attributes of an element, you need to locate the HTML tag defining that element in the inspect page window.

We need the value of the class name for our automation program. Classes generally denote a group of similar elements. The class that is highlighted in the picture, is the class of all questions within a google form.

Web Driver

A web driver drives a browser natively, emulating how a real-world user would use it. To automate a browser, we need a web driver corresponding to that browser. We should also be careful about the version of the browser while choosing a web driver. At first download the web driver. I will be using Chrome Driver for my program. You can download chrome driver from this website chromedriver.chromium.org. Once you download it, unzip the file, and copy its path. If you want to use Gradle or Maven, find the dependencies on this link.

Opening the Google form

First set the system property for working with a browser (line-1). Then create an instance of the ChromeDriver class (line-2). Use the class corresponding to the browser that you wish to use. Use the get method to open the passed URL (line-3).

String key = "webdriver.chrome.driver", value=
    "C:\\Program Files (x86)\\chromedriver_win32\\chromedriver.exe";

System.setProperty(key, value);                        //line:1

WebDriver driver = new ChromeDriver();                 //line:2
String url = "https://forms.gle/jrcqccQErE9RaBS59";
driver.get(url);                                       //line:3

See the documentation of the interface WebDriver on this link.

Finding Elements on a webpage

Selenium uses one of the following as a parameter to find elements on a webpage :

• ID
• Name
• Class Name
• Tag Name
• Link Text
• Partial Link Text
• XPath

We can use either findElement or findElements method of the WebDriver interface for finding elements in a webpage. The difference between these two methods is that the former returns the first element of the page that matches the parameter, whereas the latter returns a list containing all the elements of the page that matches the parameter.

WebElement ele = driver.findElement(By.className("some class"));

or

WebElement ele = driver.findElement(By.tag("div"));

Note that these methods are also available for each WebElement instance. In that case, however, it only considers the elements within the element that called it.

Lets say this is the HTML page we want to automate :

<div class="division">
 <p id=”para01" name=”description” class=”paragraph”>
  This is a paragraph tag.
 </p>
 <p id=”para02" name=”usage” class=”paragraph”>
  This is used to enclose a paragraph.
 </p>
</div>

And the following is the code we are writing to find elements on this page :

WebElement ele = driver.findElement(By.className("division"));
WebElement child = ele.findElement(By.className("paragraph"));

In this case, the instance ‘ele’ will contain the div of the class ‘division’’, and the instance child will contain the paragraph tag with the id ‘para01’.

Algorithm

Once we open the URL, we need to fill in random values into the Google form. For simplicity, we will only consider two input types, Multiple choice, and Short text.

Here is a simple algorithm for this :

• Since all questions on a google form belong to the same class, we can use the findelements method to retrieve the list of all the questions that are there in the form.
• Iterate through the list, and for each element check which type of question it contains. For this, again use the method findelements to retrieve a list of child elements. We can use class names for radio buttons, or text areas for this task.
• If a list is empty, it means that there are no elements corresponding to that class name within the parent element.
• If there are radio buttons, then select a random button to click. If there is a text area, then you can set any text within it. Check out the code below to see how to do these.
• Once the iteration over all the questions is completed, find the next/submit button. Click the button.
• If the above button was the next button, then repeat the above steps.

The following is the program for the above algorithm.

Similarly, we can add the usability of other kinds of Google form questions as well.

See the full project on this link.

This article was a demonstration of how Selenium can be used for automating a Google form. Similarly, we can also automate a plethora of other websites on various web browsers.

There is a wide array of resources on the internet, hosted on servers. To utilize these resources, a browser or a client program sends a request to the respective server. Most browsers access the World Wide Web which uses the HTTP protocol. Every message or request or response, communicated over the World Wide Web are essentially HTTP Requests. However, there are certain exceptions.

HTTP defines certain request methods that indicates the action to be performed. They are also referred to as HTTP verbs.

Have a look at the screenshot below:

Take a look at the URL of this video. After the name of the website (i.e., youtube.com), we can see something like a query. The URL doesn’t only specifies which website, it also contains the information about which video and a time stamp in that video.

The term ‘watch’ is used as a token for what kind of result we want (in this case a video that we want to watch), and after the question mark, there are two parameters separated by a logical ‘&’. The first part “v=24NrLl8EhDM”, acts as a video ID where as the second part “t=600s”, acts as a time stamp, i.e., if opened with this query attached, the video will open from 600 seconds (or 10 minutes).

This type of a URL is created when an HTTP request uses GET method. Various methods are used to denote what kind of action has to be performed. GET method is used to retrieve something from the server. As for our example, we are retrieving a video with that particular Video ID, opened to that particular time stamp.

A list of the HTTP request methods :

GET
To retrieve information from the given server using a given URL.

HEAD
Same as GET, but transfers the status line and header section only.

POST
To send some data to the server.

PUT
To store some data at a location specified by the given URL.

DELETE
To delete some file at the server end.

CONNECT
To establish a network with the server.

OPTIONS
To find out what methods are supported by the server.

TRACE
To echo the contents of the HTTP Request back to the requester that can be used for debugging.

Let us see where these methods are specified by looking at a Java Program.

public class RequestHandler implements HttpHandler {
@Override
public void handle(HttpExchange httpExchange) throws IOException{
   
   String method = httpExchange.getRequestMethod();
   
   try {
      if (method.equals(GET_METHOD)) {
         //Code corresponding to GET method

      } else if (method.equals(POST_METHOD)) {
         //Code corresponding to POST method

      } else if (method.equals(PUT_METHOD)) {
         //Code corresponding to PUT method

      }
   }catch (Exception e){
      
   }
}
}

The above method is an over-ridden method in the class that implements the interface HttpHandler . The method that is used can be simply extracted using the getRequestMethod() method of the HttpExchange class. To see the tutorial to create a Java Server, check my post “Develop an HTTP Server in Java”.

The following is an example of a server that can only handle GET and POST requests.

For the purpose of this tutorial, we store our data in a HashMap. However, in most original real world servers, data is retrieved from a database.

Here is a working demo for the above code :

A lot of the World Wide Web is developed on the Client-Server model. According to this structure, a task or workload is divided into two parts; a service or a resource provider, called a server, and a requester who wants to utilize the resource or the service, called a client.

On the internet, there are many different protocols that are being used. A protocol is basically a set of instructions that two machines (or software) need to follow in order to communicate. For a Client to send a request to a server and for the server to understand it, they must follow the same protocol(s). In our example I would be demonstrating the Hyper Text Transfer Protocol (HTTP).

Java has an HTTPServer class under the package com.sun.net.httpserver . We will create an object of this class, and then assign a port for the server to run on. A port is a virtual end-point within the operating system from where a network connection can start or end. Since our server has to establish communication with clients, it needs to be run on a port. We can use the class InetSocketAddress under the package java.net for this purpose.

private static void runServer() throws IOException{
   // Create a server that runs on the port 8000
   HttpServer server = HttpServerImpl.create(new
                                      InetSocketAddress(8000),0);
}

When a request is received at the server, an instance of the HTTPContext class is created. A Context describes all the HTTP-specific information about a single HTTP request.

Each HTTPContext has a path and an HTTP Request Handler. There are different types of requests that a client can make to a server. The Request Handler takes care of what needs to be done when a request is received at the server. We need to implement the HTTPHandler interface. Whenever a request is sent to the Server, the handle() method of the class that implements this interface is called. We can say that what happens at the server has to be defined in this method.

private static void runServer() throws IOException{
   HttpServer server = HttpServerImpl.create(new
                                      InetSocketAddress(8000),0);

   //Create an HTTP Context and set it's path
   HttpContext context = server.createContext("/");
   
   //Create a Request Handler for the Server
   context.setHandler(new RequestHandler());
}

class RequestHandler {
   @Override
   public void handle(HttpExchange httpExchange) throws IOException{
      //Code for what happens at the server, here we simply print
      //the request message
      InputStream inStream = httpExchange.getRequestBody();
      Scanner scanner = new Scanner(inStream);
      String data = scanner.nextLine();
      System.out.println(data);
   }
}

Every HTTP request has certain fields, that contain the information about it, like the time of arrival, the protocol used and many more along with a request body that contains some data. There are different kinds of requests like GET, POST, PUT etc. Once the request is received and processed, a response is sent back to the client, which contains all the data that it requested for. The HTTPExchange class contains all the data of the request that is received and the data of the response that would be sent back.

After setting up the Request Handler, use the method start() of HTTPServer to start running your server on the port.

Here’s the full code for making the sever :

public class Server {
   private class RequestHandler {
      @Override
      public void handle(HttpExchange httpExchange) throws
                                                    IOException{
         InputStream inStream = httpExchange.getRequestBody();
         Scanner scanner = new Scanner(inStream);
         String data = scanner.nextLine();
         System.out.println(data);
      }
   }
   private void runServer() throws IOException {
      HttpServer server = HttpServerImpl.create(new
                                         InetSocketAddress(8000),0);
      HttpContext context = server.createContext("/");
      context.setHandler(new RequestHandler());
      server.start();
   }
   
   
   public static void main(String[] args){
      try {
         Server server = new Server();
         server.runServer();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Check out my next post about making a server, “Types of HTTP Request Methods” .