software Development – Naseef Chowdhury https://naseefchowdhury.me Senior Software Engineer Fri, 26 Jul 2024 12:44:03 +0000 en-US hourly 1 https://wordpress.org/?v=6.9.4 https://naseefchowdhury.me/wp-content/uploads/2019/04/cropped-003-ads-32x32.png software Development – Naseef Chowdhury https://naseefchowdhury.me 32 32 IP/TCP Programming for Beginners Using C++ https://naseefchowdhury.me/ip-tcp-programming-for-beginners-usi/ https://naseefchowdhury.me/ip-tcp-programming-for-beginners-usi/#respond Fri, 26 Jul 2024 12:44:03 +0000 https://naseefchowdhury.me/?p=3449 IP/TCP programming is fundamental for creating networked applications, from simple chat programs to sophisticated web servers. Modern C++ offers robust features that simplify network programming. This guide will help you start with IP/TCP programming for beginners using C++.

Prerequisites

Before diving into the code, make sure you have a basic understanding of C++ and have your development environment set up. You’ll need a C++ compiler that supports C++11 or later.

Setting Up Your Environment 

Ensure you have a compiler installed, such as GCC or Clang on Linux, or Visual Studio on Windows. We’ll be using standard C++ libraries, so no additional libraries are required.

Creating a Simple TCP Server

Let’s start by creating a simple TCP server. This server will listen for incoming connections and echo any received messages back to the client.

#include <iostream>
#include <string>
#include <memory>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>constexpr int PORT = 8080;
constexpr int BUFFER_SIZE = 1024;

int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
socklen_t addrlen = sizeof(address);
char buffer[BUFFER_SIZE] = {0};
// Creating socket file descriptor
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror(“socket failed”);
exit(EXIT_FAILURE);
}
// Forcefully attaching socket to the port 8080
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror(“setsockopt”);
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(PORT);
// Bind the socket to the network address and port
if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
perror(“bind failed”);
exit(EXIT_FAILURE);
}
// Start listening for incoming connections
if (listen(server_fd, 3) < 0) {
perror(“listen”);
exit(EXIT_FAILURE);
}
std::cout << “Server listening on port “ << PORT << std::endl;
// Accept incoming connection
if ((new_socket = accept(server_fd, (struct sockaddr*)&address, &addrlen)) < 0) {
perror(“accept”);
exit(EXIT_FAILURE);
}
// Read and echo the received message
ssize_t valread = read(new_socket, buffer, BUFFER_SIZE);
std::cout << “Received: “ << buffer << std::endl;
send(new_socket, buffer, valread, 0);
std::cout << “Echo message sent” << std::endl;
// Close the socket
close(new_socket);
close(server_fd);
return 0;
}

Creating a Simple TCP Client 
Next, let’s create a simple TCP client that connects to the server and sends a message.

#include <iostream>
#include <string>
#include <memory>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>constexpr int PORT = 8080;
constexpr int BUFFER_SIZE = 1024;
int main() {
int sock = 0;
struct sockaddr_in serv_addr;
char buffer[BUFFER_SIZE] = {0};
// Creating socket file descriptor
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
std::cerr << “Socket creation error” << std::endl;
return -1;
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
// Convert IPv4 and IPv6 addresses from text to binary form
if (inet_pton(AF_INET, “127.0.0.1”, &serv_addr.sin_addr) <= 0) {
std::cerr << “Invalid address/ Address not supported” << std::endl;
return -1;
}
// Connect to the server
if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
std::cerr << “Connection Failed” << std::endl;
return -1;
}
std::string hello = “Hello from client”;
send(sock, hello.c_str(), hello.size(), 0);
std::cout << “Hello message sent” << std::endl;
ssize_t valread = read(sock, buffer, BUFFER_SIZE);
std::cout << “Received: ” << buffer << std::endl;
// Close the socket
close(sock);
return 0;
}

Explanation of the Code

Socket Creation:

Both the server and client create a socket using the socket function, specifying the address family (AF_INET for IPv4), the socket type (SOCK_STREAM for TCP), and the protocol (0 to use the default protocol for the given socket type).

 

Programming for Beginners

 

Server Binding and Listening:

The server sets socket options and binds it to a specific port (8080).
It then listens for incoming connections with the listen function.

Client Connecting:

The client specifies the server address and port, converting the IP address to the correct format using inet_pton. It then connects to the server using the connect function.

Data Transmission:

The client sends a message to the server.
The server reads the message, prints it, and sends the same message back to the client (echo).
The client reads the echoed message and prints it.

Socket Closure:

Both the server and client close their sockets after communication is done to free up resources.
Running the Code
Compile the server and client programs using your C++ compiler.

g++ -std=c++11 -o server server.cpp
g++ -std=c++11 -o client client.cpp

Run the server program first.

./server

In another terminal, run the client program.

./client

You should see the server receiving the message from the client and echoing it back.

Conclusion

This guide briefly introduced IP/TCP programming for beginners using modern C++. By leveraging the standard library and C++ features, you can create efficient and maintainable networked applications. While this example uses basic socket programming, more advanced applications may benefit from higher-level libraries. However, understanding the fundamentals empowers you to build more complex and robust networked systems. Happy coding!

References
https://www.geeksforgeeks.org/tcp-server-client-implementation-in-c/

]]> https://naseefchowdhury.me/ip-tcp-programming-for-beginners-usi/feed/ 0 The Negative Impact of Large Language Models on Software Developers (Naseef Chowdhury) https://naseefchowdhury.me/negative-impact-of-large-language-models/ https://naseefchowdhury.me/negative-impact-of-large-language-models/#comments Thu, 11 Jul 2024 08:44:38 +0000 https://naseefchowdhury.me/?p=3379 Large Language Models (LLMs) like GPT-4, Bard, and others have revolutionized various fields, including software development. While these AI-powered tools offer numerous benefits, they also bring along several negative impacts on software developers. This article explores these drawbacks, emphasizing how LLMs can potentially hinder development, affect job roles, and lead to ethical and practical challenges.

Reduced Skill Development and Critical Thinking

One of the most significant concerns with the increasing reliance on LLMs is the potential decline in developers’ critical thinking and problem-solving skills. LLMs can handle many routine tasks, such as code generation, debugging, and documentation, which developers traditionally perform by developers.

Over-Reliance on AI

Developers might become overly dependent on these tools, leading to a reduced understanding of the underlying principles and nuances of coding. This dependency can result in a workforce that cannot troubleshoot complex issues independently, relying instead on AI-generated solutions.

Decline in Learning Opportunities

With LLMs taking over many coding tasks, developers, especially those at the entry-level, may miss out on crucial learning opportunities. Hands-on experience and solving real-world problems are essential for honing a developer’s skills. The reduced necessity to write and debug code manually can lead to a superficial understanding of software development.

Job Displacement and Role Changes

The automation capabilities of LLMs pose a threat to traditional developer roles. Tasks that once required human intervention are now being handled by AI, leading to job displacement and a shift in job roles.

Risk of Job Loss

While AI can enhance productivity, it can also reduce the demand for certain types of developer roles. Routine coding tasks, code reviews, and even some aspects of project management can be automated, potentially leading to job losses.

Evolution of Job Roles

The introduction of LLMs necessitates new skill sets and roles. Developers might need to transition into roles that focus on managing and refining AI tools, ensuring ethical use, and interpreting AI-generated outputs. This shift requires additional training and adaptation, which can be challenging for the existing workforce.

Large Language Models
 

Ethical and Practical Challenges

The use of LLMs in software development is not without ethical and practical challenges. These concerns need to be addressed to ensure that AI tools are used responsibly.

Bias and Fairness

LLMs are trained on vast datasets that may contain biases. When these models are used in software development, they can perpetuate existing biases, leading to unfair or discriminatory outcomes. Ensuring that AI tools produce fair and unbiased results is a significant challenge.

Transparency and Accountability

The decision-making processes of LLMs are often opaque. This lack of transparency can lead to accountability issues when AI-generated code causes errors or security vulnerabilities. Developers and organizations must implement measures to maintain transparency and accountability in AI-driven development processes.

Security and Privacy

Using LLMs involves processing potentially sensitive code and data. Ensuring the security and privacy of this information is paramount to prevent unauthorized access or data leaks. Robust security measures and ethical guidelines are necessary to protect sensitive information.

Conclusion

While Large Language Models have the potential to revolutionize software development, their negative impacts on developers cannot be ignored. Reduced skill development, job displacement, and ethical challenges are significant concerns that need to be addressed. By balancing the benefits of LLMs with their potential drawbacks, the software development community can ensure that AI tools enhance rather than hinder the development process.

Developers and organizations must be proactive in addressing these challenges, fostering an environment where AI tools are used responsibly and ethically. This approach will ensure that the integration of LLMs into software development brings about positive change while mitigating the negative impacts on developers.

References

  1. https://www.geoffreylitt.com/2023/03/25/llm-end-user-programming.html

]]> https://naseefchowdhury.me/negative-impact-of-large-language-models/feed/ 1