Arunangshu Biswas | Software Engineer

The Power of Object-Oriented Programming: Building Maintainable Code

Wed, 12 Jul 2023 14:24:06 GMT

Introduction

Once upon a time, programming was a mystic art! An art that could only be performed by the ones well versed in the way of computers. But this image of programming has long been changed. There are many tutorials out there both in texts and videos that make this art much easier to learn. One can learn any language and build their applications. But is that all? Or is there more to this than meets the eye?

The Story

You can now get started with building your app in any language. You settle on Python as it is a beginner-friendly language. You google “Python tutorial” select one of the top results and start learning the language. You are now ready and one step closer to building your app. During this journey, many errors are going to attack and prevent you from completing the app, but your Google-Fu is top-notch. Those puny errors will be of no match to you! After all the think, write, and debug cycles you have reached your goal. That app you wanted to build is now ready!

Now happy and excited, you show off your learnings to your peers. You get compliments and also some interesting feedbacks for additional features. Inspired by the well build apps from big companies such as Microsoft, Google and Adobe, you decide to improve your app. You get to work and start writing code to add all those cool features your friends suggested. But wait! Now you are facing a different kind of problem. Your codebase is now a whopping 200 lines long, and now you’re finding it difficult to add new code. The errors are now much more frequent with functionalities breaking on adding new code. Being frustrated, you decide to take a few days of break.

Now with a fresh spirit and mind, you decide to complete your app. You start scanning through your code to reach the point where you left off. But to your horror, you are now facing difficulties understanding your own code. Still undeterred, you push yourself for a couple of hours. To your dismay, you are still facing the same trouble as before. You lose all your motivation and finally decide to quit.

So what happened? What went wrong?

The Analysis

What you are experiencing is a classic problem of poor code structuring. This leads to low maintainability and makes it very hard to add new code. This is common in many beginner’s projects where the main focus is on functionality. So how do we write code which is not only functional but also easily maintainable and extendable?

The Solution

The term “Object-Oriented Programming (OOP)” was coined by Alan Kay at grad school in 1966 or 1967. It took off in the software industry, replacing the largely prevalent procedural programming paradigm.

The advantages of using this new paradigm are,

It improves simplicity, as the software objects are analogous to the real-world objects. It brings down the program’s complexity by providing an intuitive idea about the structure.
It encourages modularity, as each object is a separate entity that is decoupled from each other.
It improves extensibility, as OOP has the concept of classes and inheritance where a class can extend upon the functionality of another class.
It increases modifiability, as we can change the internal implementation of class methods which would not affect other classes provided we don’t change the public interface. The internal implementations of objects are abstracted away from each other.
It improves maintainability, as classes are self-contained they can be maintained separately. This makes locating and fixing errors easier.
It encourages reusability, as we can instantiate a class anywhere and any number of times.

So following the OOP paradigm, we can easily resolve our code extensibility and maintainability issues. But hold on! how do we learn about it?

The Path

The OOP paradigm is a vast field with many programming languages that have slightly different implementations of it. But there are some core concepts that one needs to learn first to grasp it.

Encapsulation
Abstraction
Inheritance
Polymorphism

I believe in the philosophy of Learn by Doing, where you learn about something by getting hands-on with it. I have recently completed some exercises at Crio.Do on the said concepts. Solving a real-world based problem using the learned concepts goes a long way by solidifying the intuition and the concept together.

Conclusion

At the beginning of every programmer’s life, their first major project is a structural mess. Learning the basic OOPS concepts helps to introduce a structure to the code. But this is just the beginning of the journey. There are more stuff to learn like SOLID and GRASP principles and so on. This journey is a continuous evolution and has no real end. As the applications scale and the requirements change, there might arise a need for a new structure in the future. So staying updated is a crucial job for a developer in this ever-changing field of IT.

So good luck with your journey! And thanks for taking the time to read my article.

Protohackers - 0: Smoke Test

Mon, 17 Jul 2023 14:48:31 GMT

Problem summary

The task is to create a generic server that implements the TCP Echo Service from RFC 862. The server should accept TCP connections and be capable of handling at least five simultaneous clients. Its main functionality is to receive data from clients and send it back unmodified. The server must handle binary data without altering it. Once a client finishes sending data and closes it’s sending side, the server should close the corresponding socket after receiving and echoing all the data. This behavior aligns with the requirements specified in the TCP Echo Service definition.

Problem statement link: https://protohackers.com/problem/0

Code

package main

import (
    "fmt"
    "io"
    "log"
    "net"
)

var PORT = 80

func RunServer() {
    for {
        // Listen for incoming connections
        log.Print("Listening on port ", PORT, " for incoming connections.")
        lst, err := net.Listen("tcp", ":"+fmt.Sprint(PORT))
        if err != nil {
            // Handle error
            log.Fatal(err)
        }

        // Echo all incoming data.
        for {
            // Accept a TCP connection
            conn, err := lst.Accept()
            if err != nil {
                // Handle error
                log.Fatal(err)
            }

            log.Print("Accepted connection from ", conn.RemoteAddr().String())
            go handleConnection(conn)
        }
    }
}

func handleConnection(c net.Conn) {
    defer c.Close()

    io.Copy(c, c)

    log.Print("Closing connection to ", c.RemoteAddr().String())
}

func main() {
    RunServer()
}

Breakdown

package main

import (
    "fmt"
    "io"
    "log"
    "net"
)

This section specifies that the code is part of the main package, which is the default package for an executable Go program. Several libraries are then imported:

fmt: This package contains functions for formatted I/O.
io: This package provides basic interfaces to I/O primitives.
log: This package provides simple logging services.
net: This package provides a portable interface for network I/O, including TCP/IP, UDP, and Unix domain sockets.

var PORT = 80

Here a global variable PORT is declared and initialized to 80. This is the port that the server will listen on for incoming connections.

func RunServer() {
	for {
		log.Print("Listening on port ", PORT, " for incoming connections.")
		lst, err := net.Listen("tcp", ":"+fmt.Sprint(PORT))
		if err != nil {
			log.Fatal(err)
		}

		for {
			conn, err := lst.Accept()
			if err != nil {
				log.Fatal(err)
			}

			log.Print("Accepted connection from ", conn.RemoteAddr().String())
			go handleConnection(conn)
		}
	}
}

The RunServer function starts an infinite loop that listens for incoming connections on the specified port. If it encounters an error, it logs the error and terminates the program. If it successfully accepts a connection, it prints a log message stating that it has accepted the connection from the remote address, and calls the handleConnection function in a separate goroutine, passing the connection to it.

func handleConnection(c net.Conn) {
	defer c.Close()

	io.Copy(c, c)

	log.Print("Closing connection to ", c.RemoteAddr().String())
}

This function is used to handle a new connection. It uses the defer statement to ensure that the connection will be closed when the function exits, regardless of how it exits. It then copies data from the connection to itself, effectively echoing all incoming data back to the client. Once the connection is closed, a log message is printed to indicate this.

Note: io.Copy(c, c) is a simple echo operation. It copies data from the source (the connection itself) to the destination (again, the connection itself). So, whatever data the server receives from a client, it sends the same data back to the client.

func main() {
    RunServer()
}

The main function is the entry point for the executable program. It simply calls the RunServer function to start the server. The server will then listen indefinitely for incoming connections on the specified port.