Forem: CoderLegion

[Boost]

CoderLegion — Fri, 26 Sep 2025 00:59:37 +0000

The 2-Minute Technical Debt Killer That Saved My Team 200 Hours

Pratham naik for Teamcamp ・ Sep 23

Introducing CoderLegion, A Community for Coders, by Coders...

CoderLegion — Mon, 21 Jul 2025 08:20:43 +0000

In today’s fast-moving tech world, staying sharp means staying connected. That’s why CoderLegion was created — to bring developers and tech enthusiasts into one vibrant, open community. Whether you’re launching your first side project, writing your 100th tutorial, or sharing your latest coding video, CoderLegion is your space.

🚀 A Mission That Matters

At CoderLegion, we believe coding isn’t just about syntax — it’s about building, sharing, and growing together.

Our mission:
To empower developers around the world through a community-driven platform for sharing knowledge, experiences, and innovation.

We’re not just another tech forum. We’re a space where ideas turn into projects, strangers become collaborators, and breakthroughs get noticed.

💡 Why CoderLegion Stands Out

Open to All Skill Levels
Beginners, intermediates, pros — everyone is welcome to ask, post, and participate.
Launch Projects & Products
Share what you’re building — from side hustles to full-scale apps. Get early feedback and visibility from a real dev community.
Post Videos & Tutorials
Got a screencast, walkthrough, or coding talk? Upload it directly or embed from platforms like YouTube or Loom.
Tech Stack–Agnostic
Whether it’s Python, Rust, C++, TypeScript, or something niche like Haskell or Pascal — we support all dev flavors.
Community-First Philosophy
CoderLegion evolves based on your feedback. Feature suggestions? UI complaints? We want to hear them all.

🧪 Coming Soon: Developer Groups

We’re excited to announce that niche-focused developer groups are coming to CoderLegion very soon.

Anyone can create a group around a topic, tech, or goal (e.g., "Frontend Wizards", "Indie Hackers AU", "Rustaceans").
Group admins can moderate posts, invite members, and build micro-communities.
Great for team collabs, local meetups, and focused discussions.

Keep an eye out — this launches in the next product cycle!

🤝 Powered by Community Leaders

At the heart of CoderLegion are our Community Leaders — active members who welcome new users, spark discussions, and set the tone for quality and kindness.
Want to become one? Just stay active, helpful, and consistent — we notice and invite contributors regularly.

Meet some of them here:
👉 coderlegion.com/users/leaders

🌱 How You Can Get Involved

Whether you’re just browsing or ready to contribute, here’s how to jump in:

Post a tutorial or launch your product
Join discussions or leave thoughtful comments
Embed a demo video or record a quick dev tip
Give feedback — UI bugs, feature ideas, anything!

🧭 Built in the Open

We’re a small team building CoderLegion transparently and in real-time. Some parts may feel raw or incomplete — and that’s because we ship fast and improve based on your input.
Found an issue? Send it our way. You’re helping shape this platform.

Join the Fastest-Growing Developer Community

CoderLegion — Sun, 23 Mar 2025 03:56:44 +0000

Join the Fastest-Growing Developer Community!

Network with fellow developers, share knowledge, and grow your career.

Join Now – It's Free!

Why Join?

Grow Your Knowledge
Access thousands of programming articles.

Engage with Developers
Join discussions & ask questions.

Boost Your Profile
Get featured for valuable contributions.

Earn Rewards
Gain points, badges & reputation.

Trusted by Thousands of Developers

1,200+ Members | 4,000+ Discussions | 100+ Top Contributors

How It Works

✅ Sign Up – Create a free account in seconds.
✅ Engage – Post, comment, and interact with top developers.
✅ Earn & Grow – Gain recognition, earn points & showcase expertise.

Join CoderLegion Now – It’s Free!
No spam, no excessive ads—just a pure developer community!

ThDatabase Interaction using Python: Introduction to SQLite/MySQL/PostgreSQLis is a test article

CoderLegion — Sun, 23 Mar 2025 03:55:47 +0000

⚡ Before you dive into this article... Check out our new community at CoderLegion.com! Share your knowledge, connect with like-minded developers, and grow together. Click here to join now!

The article covers POSTGRESQL, MySQL, and SQLITE3—three major database management systems. They provide unique features and benefits and are essential to software development. Let's explore their features so that you can make better selections that will improve the project. Together, let's explore these essential elements in modern software engineering.

As SQLite is lightweight, it is a great choice for embedded applications and situations where simplicity is essential. On the other hand, MySQL stands out thanks to its strong client-server design, scalability, and widespread industry acceptance. PostgreSQL, on the other hand, is a popular option for enterprise-level applications due to its versatility, dependability, and compliance with ACID short for Atomicity, Consistency, Isolation, and Durability.

SQLite Database
SQLite is a relational database engine that is lightweight, serverless, self-contained, and requires no configuration. Because it works directly with files, it's perfect for low-resource applications. Distribution and deployment are made easier by the fact that its self-contained databases are kept as single files.

Features:

Embedded in applications: SQLite, which is frequently integrated into programmes, allows internal data administration without the need for external servers. Data management is made easier by this, especially for offline functioning.
File-based database: SQLite databases are manageable and portable since they are kept as individual files on the file system.
Appropriate for small to medium-sized applications: Because of its simplicity and lightweight design, SQLite is especially well-suited for small to medium-sized applications, even though it can manage huge datasets as well.
Let's go through an example of defining tables, installing SQLite in Python, and carrying out CRUD (Create, Read, Update, Delete) operations:

conn = sqlite3.connect('example.db')
cursor = conn.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS users
(id INTEGER PRIMARY KEY, name TEXT, email TEXT)''')
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Alice', 'Emails are not allowed'))
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Ali', 'Emails are not allowed'))
print("Records after initial insertion:")
cursor.execute("SELECT DISTINCT * FROM users")
rows = cursor.fetchall()
for row in rows:
print(row)
cursor.execute("UPDATE users SET email = ? WHERE name = ?", ('Emails are not allowed', 'Alice'))
print("\nRecords after updating email of Alice:")
cursor.execute("SELECT DISTINCT * FROM users")
rows = cursor.fetchall()
for row in rows:
print(row)
cursor.execute("DELETE FROM users WHERE name = ?", ('Alice',))
print("\nRecords after deleting Alice:")
cursor.execute("SELECT DISTINCT * FROM users")
rows = cursor.fetchall()
for row in rows:
print(row)
Output:

Tip: Make sure the 'DISTINCT' keyword is applied to the right columns in SQL queries to obtain unique value combinations and prevent accidental duplicate results.
MySQL Database
The popular open-source RDBMS MySQL provides strong features and dependability for systems ranging from small-scale initiatives to enterprise-level setups. It offers a wide range of tools and features for effective structured data management.

Features:

Client-server architecture:MySQL has a client-server design, which enables several clients to connect to the database server at once. The management of database resources, scalability, and security are all improved by this architecture.
Performance and scalability: MySQL is designed to be scalable, meaning it can manage big databases and high transaction volumes while maintaining optimal performance. Performance is improved by its effective caching, query optimisation, and indexing methods.
Broad industrial adoption: MySQL is widely used in a number of industries, including telecommunications, e-commerce, technology, and finance. Its widespread community support, dependability, and open-source nature have all added to its appeal.
You can get the MySQL Community Server package from mysql official website and install MySQL by following the given steps. As an alternative, you can use package managers such as Homebrew for macOS or apt-get for Linux.

Connecting to MySQL from Python:

import mysql.connector
conn = mysql.connector.connect(user='user', password='password',
host='localhost',
database='test')
cursor = conn.cursor()
cursor.execute("SELECT * FROM table_name")
results = cursor.fetchall()
conn.close()
Creating tables and executing queries using Python's MySQL Connector:

cursor = conn.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS users
(id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), email VARCHAR(255))''')
cursor.execute("INSERT INTO users (name, email) VALUES (%s, %s)", ('Alice', 'Emails are not allowed'))
cursor.execute("SELECT * FROM users")
results = cursor.fetchall()

PostgreSQL Database
Strong and open-source, PostgreSQL is an object-relational database system that is well-known for its feature-rich set, dependability, and extensibility. It is a top option for both small-scale applications and large corporate systems because of its comprehensive functions that enable complicated data types, transactions, and data integrity.

Features:

Extensibility: Because of PostgreSQL's flexible architecture, programmers are able to design unique functions, data types, and indexing techniques to meet the needs of particular applications. The smooth integration of third-party extensions and libraries is made possible by this flexibility.
ACID Compliance: PostgreSQL guarantees ACID (
Atomicity: To preserve database integrity, transactions are either fully completed or entirely aborted.
Consistency: Assures that the database is kept intact by writing only legitimate data.
Isolation: Data integrity is ensured by many transactions running simultaneously without interfering.
Durability: Even in the event of a system failure, committed transaction modifications remain intact.) compliance, which in turn provides dependable and consistent database transactions. This functionality is crucial for ensuring consistency across the database and data integrity even in the case of system failures.
Data Integrity and Reliability: PostgreSQL uses built-in restrictions like triggers and rules, foreign keys, and concurrency management to guarantee data integrity and stability.
To install PostgreSQL, you can download and install the PostgreSQL package from the official website.

import psycopg2
conn = psycopg2.connect(
dbname='your_database_name',
user='your_username',
password='your_password',
host='localhost',
port='5432'
)
if conn:
print("Connected to PostgreSQL")
else:
print("Failed to connect to PostgreSQL")
conn.close()
Creating tables and executing queries using Python's psycopg2 library:

Create a cursor object

cursor = conn.cursor()
cursor.execute('''CREATE TABLE IF NOT EXISTS users (
id SERIAL PRIMARY KEY,
name VARCHAR(255),
email VARCHAR(255)
)''')
cursor.execute("INSERT INTO users (name, email) VALUES (%s, %s)", ('Alice', 'Emails are not allowed'))
cursor.execute("SELECT * FROM users")
results = cursor.fetchall()
for row in results:
print(row)
conn.commit()
Note: Always securely handle database credentials and avoid hardcoding them directly into your code for better security.
Comparison
Factor SQLite MySQL PostgreSQL
Performance
Good for
small to medium
-sized applications

Optimized for
read-heavy
workloads Optimized for
complex
queries
and large
datasets
Scalability Limited scalability
due to file-
based architecture Good scalability
with support for
clustering and
sharding High scalability
with advanced
replication and
partitioning
Features Basic features with limited concurrency support Rich feature set including stored procedures, triggers, and views Comprehensive feature set including JSONB data type,
full-text search, and
advanced indexing
Ease of Use Simple setup and usage, suitable for beginners Easy to use, especially
with graphical tools like MySQL Workbench Requires more
configuration but
offers powerful features
Use Case Suitability Ideal for
embedded
systems
and small
applications

Well-suited for web applications
and medium-
sized databases

Best for large-scale applications with
complex data
requirements
Advanced Concepts
Advanced ideas like indexing, optimization, and transactions are essential for improving the scalability, performance, and dependability of databases.

Transactions: Transactions ensure the ACID properties of database operations, handling multiple tasks as a single unit for data accuracy and reliability. All database systems provide tools for effective transaction management.
Indexing: Indexes expedite data retrieval, particularly for SELECT queries, by swiftly accessing entries in database tables based on specific field values. Effective indexing reduces the need for full table scans, significantly enhancing query performance.
Optimization: Database optimization strategies improve effectiveness and performance through resource usage optimization, performance tuning, query optimization, and schema design optimization. Each system provides unique features and tools to enhance productivity and address performance issues.
import sqlite3
import mysql.connector
import psycopg2
def sqlite_transactions():
conn = sqlite3.connect('example.db')
cursor = conn.cursor()
try:
conn.execute("BEGIN")
cursor.execute("UPDATE users SET balance = balance - 100 WHERE id = 1")
cursor.execute("UPDATE users SET balance = balance + 100 WHERE id = 2")
conn.commit()
print("Transaction committed successfully")
except sqlite3.Error as e:
conn.rollback()
print("Transaction rolled back due to error:", e)
finally:
conn.close()
def mysql_transactions():
conn = mysql.connector.connect(user='user', password='password', database='example')
cursor = conn.cursor()
try:
conn.start_transaction()
cursor.execute("UPDATE users SET balance = balance - 100 WHERE id = 1")
cursor.execute("UPDATE users SET balance = balance + 100 WHERE id = 2")
conn.commit()
print("Transaction committed successfully")
except mysql.connector.Error as e:
conn.rollback()
print("Transaction rolled back due to error:", e)
finally:
conn.close()
def postgres_transactions():
conn = psycopg2.connect(dbname='example', user='user', password='password', host='localhost')
cursor = conn.cursor()
try:
conn.autocommit = False
cursor.execute("UPDATE users SET balance = balance - 100 WHERE id = 1")
cursor.execute("UPDATE users SET balance = balance + 100 WHERE id = 2")
conn.commit()
print("Transaction committed successfully")
except psycopg2.Error as e:
conn.rollback()
print("Transaction rolled back due to error:", e)
finally:
conn.close()
sqlite_transactions()
mysql_transactions()
postgres_transactions()
SQLite, designed for single-user and small-scale applications, uses local file-based databases and simple transaction management with BEGIN, COMMIT, and ROLLBACK statements.
MySQL, a robust RDBMS, offers scalability and concurrency control with start_transaction(), commit(), and rollback() methods.
PostgreSQL, known for advanced features and extensibility, provides strong support for concurrency, data integrity, and advanced SQL features, managing transactions via autocommit mode and commit()/rollback() methods.

FAQ

Q: What is the difference between SQL and NoSQL databases?
A: SQL (Structured Query Language) databases, also known as relational databases, organize data into tables with predefined schemas and use SQL for querying. NoSQL databases, on the other hand, store data in flexible, non-tabular formats and do not require a fixed schema. They are designed for scalability and handling unstructured data.
Conclusion
Databases are essential to software development because they allow for effective data management. MySQL scales for the web, PostgreSQL meets enterprise needs, and SQLite is ideal for lightweight applications. When choosing a project, it is essential to comprehend their strengths. Using cutting-edge ideas promotes creativity in digital solutions by ensuring data performance and dependability.

Reference
For more reference:
SQLite Official Website:
SQLite Official Website

Advanced Python Concepts - Networking with Python

CoderLegion — Sun, 01 Dec 2024 10:58:55 +0000

⚡ Before you dive into this article... Check out our new community at CoderLegion.com! Share your knowledge, connect with like-minded developers, and grow together. Click here to join now!

Have you ever wondered how your device is connected over the Internet? Or how the business manages to share information across regions seamlessly? All this is achieved using computer networks as part of the business strategy. It allows us to establish communication, collaborate, and share resources among different applications and devices in the network over the Internet. Now, you can contact or share things with your friends or anyone with just one click, thanks to the integration of networking with software applications, and various other technologies. In Python, networking is a fundamental concept that enables the interaction between devices and external resources. Python includes many built-in modules that support networking capabilities, such as `socket` for general networking and `requests` for HTTP communication.
Therefore, in this article, we will discuss networking from its basic concepts to advanced concepts in Python using practical examples.

Introduction to Networking Concepts

1. Networking and Its Significance In Distributed Systems

Networking involves connecting multiple computers and devices via wired cables or wireless networks to exchange data and share resources over the Internet. It allows communication between multiple devices. As we know, distributed systems are those in which large numbers of clients, hardware devices, and processes are connected to share resources and communicate. Therefore, networking and distributed systems are significantly interconnected. They provide the infrastructure that facilitates storage, resource sharing, and electronic communication to enhance the efficiency and productivity of the system.

2. Key Networking Concepts

Some key networking concepts that we use in our day-to-day lives are as follows:

2.1. IP Address

An IP address uniquely identifies your device on a network. If you have a device that connects to the Internet, it must have an IP address. IP stands for Internet protocol. It is a unique number or an identifier for the computer or device within the network. Every device would have a unique number that makes it different from the other devices within the network. For example:

IPv4: 32-bit address: 192.168.1.1 
IPv6: 128-bit address: 2001:0db8:85a3:0000:0000:8a2e:0370:7334

Note:

An IP address is a unique string of numbers separated by full stops that identifies each computer that uses the Internet protocol to communicate over a network.

2.2. Port

A port is a numerical identifier used in networking to specify a particular service or process on a device. In contrast with an IP address, which identifies the location of a device on a network, ports allow multiple services to operate concurrently on the same device. It ensures that data is directed to the correct application or process. These ports are ranges from 0 to 65535, having certain scale reserved for specific protocols. For example:

HTTP uses port 80  
HTTPS uses port 443

2.3. Protocol

A network protocol is a set of procedures and practices for communication between network devices. It defines how data are formatted, transmitted, and received. Examples include HTTP, FTP, SMTP, and DNS. Protocols can operate at various layers in the OSI model, such as the application layer (HTTP), transport layer (TCP), and network layer (IP).

2.4. Sockets

A socket is a network endpoint for sending or receiving data across multiple devices. It involves a pairing of an IP address and a port number. Sockets can be of two main types: SOCK_STREAM for TCP connections, which are connection-oriented, and SOCK_DGRAM for UDP connections, which are connectionless. Sockets enable the implementation of various network services, such as web and email servers.

3. OSI Model and The TCP/IP Stack

Certain models are defined that tell us how to connect our devices or computers over the Internet so that they can interact and communicate with each other. There are two primary models for defining networking. OSI model or TCP/IP stack. Let us get an overview of each of them briefly:

3.1. TCP/IP Stack

The TCP/IP stack is a suite of communication protocols used to interconnect network devices on the Internet, ensuring reliable data transmission and communication. It is a set of procedures on how computers can interact and how to design those systems. To understand the functions, it is divided into five layers. Each layer has its work, and these are the Application, Transport, Network Access, Data Link, and Physical layers. The TCP/IP stack provides a practical implementation of networking in the real world in contrast with the OSI model, which provides a theoretical understanding of networking communication. In addition, the Transport layer provides the facility for reliable data transmission, and Network Access ensures the correct IP address and routing of data packets, and so on.

3.2. OSI Model

Similar to TCP/IP, the OSI model is also used to design the network across multiple devices. It is a conceptual framework consisting of a set of procedures for understanding and implementing network protocols in seven different layers. It shares the same layer as TCP/IP, with an additional layer. These includes: Application, Presentation, Session, Transport, Network Access, Data Link, and Physical Layer. Specifically, the main difference between OSI and TCP/IP is the two additional layers molded into the application layer of TCP/IP.

Socket Programming Basics

1. Socket Programming As The Foundation Of Networking In Python

Networking involves the connection of two or more devices such that communication is possible within them. In Python, sockets programming is a fundamental and core network creation mechanism. For socket programming, we need to import the socket module. Using the socket module, a developer can generate, configure, and manage sockets for TCP and UDP communication. This module has many built-in methods required for creating sockets and helping them associate with each other. A few important methods that are used are socket.socket, which is used to create a socket. This socket is used on both the client and server sides. Moreover, to accept the communication, we use the socket.accept method.

Note

TCP stands for transmission control protocol, which is a connection-oriented protocol that ensures reliable data transfer. UDP is a user datagram protocol, a connectionless protocol that prioritizes speed over reliability.

2. Sockets As Endpoints For Communication Between Machines

Sockets are the network endpoints used for sending and receiving data. By default, a single network has two sockets, one for each communication device. These sockets combine IP addresses and port numbers. In addition, a single device can have N sockets based on the port number used. Different ports are available for different types of protocols; for example, HTTP uses port 80. Through this endpoint mechanism, developers can ensure an accurate and reliable exchange of data in various networking scenarios.

3. Example: Creating and Using Sockets for Basic Network Communication

Now that we have understood what socket programming is as it is the foundation of Python programming, let's move to the code editor and see how we can create it. We must create two different files for the client and server sides to establish the connection.

server.py

import socket #Import library

#Create a socket object and then define two arguments first one specifies the IP address
#and second indicate the use of a TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Prepare to receive connections by binding it to the IP address and port
soc.bind((socket.gethostname(), 1042))
#Listen to the connection
soc.listen(5)

while True:
     #Set client socket and address and make a connection
     clt, addr = soc.accept() 
     print(f"Connection Established to address {addr}")
     msg = "Message Received and the message is ->"
     clt.send(bytes(msg + "Socket Programming in Python", "utf-8"))

client.py

import socket #Importing the module

#Create a socket object and then define two arguments first one specifies the IP address
#and second for indicating the use of a TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Set the connection with the port number and hostname
soc.connect((socket.gethostname(), 1042))
#Set the bytes of the message how much you want to receive
msg = soc.recv(100)
print(msg.decode("utf-8"))

Working with TCP/IP

1. Transmission Control Protocol (TCP) And Its Role in Communication

TCP, also known as transmission control protocol, is a transport layer protocol within the TCP/IP model. It consists of a set of protocols and procedures that decide how to send data over the Internet. Usually, when data are sent as files, they are broken down into individual packets. When packets arrive at the destination with a unique number for each packet. We can assemble them with it. In addition, if some packets are missing, TCP ensures that they are resend. This is why we call TCP a reliable protocol for communication because it establishes communication through the handshake process, acknowledges the received data, and retransmits lost packets by maintaining the correct order of packets and ensuring data integrity and delivery.

2. Example: Creating TCP Client And Server Applications In Python

The server is the software that waits for the client's request, and the client requests the resources from the server. Socket programming is mostly implemented for the client-server architecture. Here, we discuss the example of creating a client and a server where the client sends a message, and the server responds to that message and gives the appropriate response to that request using the socket module with TCP. Let us design both the client and server model.

server.py

import socket #Import socket library

def start_server():
    #Create a TCP/IP socket
    #Create a socket object and then define two arguments first one specifies the IP
address
    #and second for indicating the use of a TCP socket.
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    #Bind the socket to the port
    server_address = ('localhost', 65432)
    print('Starting server on {} port {}'.format(*server_address))
    server_socket.bind(server_address)

    #Listen for incoming connections
    server_socket.listen(1)

    while True:
        #Wait for a connection
        print('Waiting for a connection')
        connection, client_address = server_socket.accept()
        try:
            print('Connection from', client_address)

            #Receive the data and send it back
            while True:
                data = connection.recv(1024)
                if data:
                    print('Received: {}'.format(data.decode()))
                    connection.sendall(data)
                else:
                    print('No more data from', client_address)
                    break
        finally:
            #Clean up the connection
            connection.close()

if __name__ == '__main__':
    start_server()

client.py

import socket #import socket library
def start_server():
    #Create a TCP/IP socket
    #Create a socket object and then define two arguments first one specifies the IP address
    #and second for indicating the use of a TCP socket.
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    #Connect the socket to the server's port
    server_address = ('localhost', 65432)
    print('Connecting to {} port {}'.format(*server_address))
    client_socket.connect(server_address)

    try:
        #Send data
        message = 'Hello, Server!'
        print('Sending: {}'.format(message))
        client_socket.sendall(message.encode())

        #Look for the response
        amount_received = 0
        amount_expected = len(message)

        while amount_received < amount_expected:
            data = client_socket.recv(1024)
            amount_received += len(data)
            print('Received: {}'.format(data.decode()))

    finally:
        #Close the socket
        print('Closing socket')
        client_socket.close()

if __name__ == '__main__':
    start_client()

3. Building A Simple Chat Application Using TCP Sockets

Let us create a simple chat application in Python using TCP sockets, where the server listens to the incoming commands and the client connects to that server to send and receive messages. We are going to build the chat room using the Python built-in module i.e. socket. So, we need to write code for each side like the client and the server, separately:

server.py

import socket #Import library

#Create a socket object and then define two arguments first one specifies the IP address
#and second for  indicating the use of TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Prepare to receive connections by binding it to the IP address and port
soc.bind((socket.gethostname(), 1042))
#Listen the connection
soc.listen(5)
print("Server listening...")

#Set client socket and address and make connection
clt, addr = soc.accept() 
print(f"Connection Established to address {addr}")

try:
    while True:
        data = clt.recv(1024).decode('utf-8')
        if not data:
            break
        print(f"Received from client: {data}")
        clt.send("Message received".encode('utf-8'))
finally:
    clt.close()
    soc.close()

client.py

import socket #Importing the module

#Create socket object and then define two arguments first one specifies the IP address
#and second for  indicating the use of TCP socket.
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Set the connection with the port number and hostname
soc.connect((socket.gethostname(), 1042))
#Set the bytes of message how much you wanna receive
try:
    while True:
        message = input("Enter your message: ")
        soc.send(message.encode('utf-8'))
        data = soc.recv(1042).decode('utf-8')
        print(f"Received from server: {data}")
finally:
    soc.close()

Wrapping Up

Networking is a crucial concept in computer science and programming. It resolves most human problems, whether you are working in your office or sharing files with your team. Alternatively, contact a relative from another country. In summary, we focused on the solid introduction of networking foundations using Python. We learned the essential topics of network controls and models, client and server architecture, and practical examples using the socket library. This library ensures the establishment of a secure and reliable network for distributed systems. Keep experimenting and building upon these skills to further enhance your proficiency in network programming. Hope this guide is helpful. Thank you for reading. Happy Coding!

Reference

Networking in Python

Socket library

Advanced Python Concepts - Metaprogramming

CoderLegion — Sun, 01 Dec 2024 10:56:21 +0000

Imagine writing a Python code that can modify itself or dynamically generate new code based on the real-time data input. Metaprogramming is a powerful and advanced technique of programming that allows developers to write code that can manipulate other code and generate new code during runtime. Like we say, metadata is data of data, and metaprogramming is also about writing code that manipulates code. Therefore, this article discusses metaprogramming capabilities to enhance code efficiency and flexibility. We will learn about its foundation, decorators, metaclasses, and dynamic code execution by providing practical examples of each concept. Let's get started!

Understanding Metaprogramming

1. Metaprogramming And Its Role In Python

In Python, metaprogramming is about writing computer programs that will assist in writing and manipulating other programs. This technique allows programs to treat other programs as data. It generates the code, modifies the existing code, and creates a new programming construct at runtime.

2. Metaprogramming And Regular Programming

Before moving on to the technical aspects of metaprogramming concepts, let us first see how generic or regular programming that is based on procedural steps differs from advanced programming concept.

3. Benefits And Risks Of Using Metaprogramming

Metaprogramming provides us with a range of benefits. Let's explore them to understand their advantage in the development process.

Metaprogramming reduces development time by allowing programs to modify themselves at runtime. This technique enables developers to write less code, making the overall development process more efficient compared to traditional software development methods.
It provides solutions to code repetition and reduces the coding time. As we know, metaprogramming is all about reducing the code from the developer end and creating an automated way of generating code at run time.
The programs adapt their behavior dynamically at runtime in response to certain conditions and input data. This makes the software program more powerful and flexible.

Similar to the benefits, metaprogramming also comes with some drawbacks as well, which the developer keeps in mind before using this technique.

One risk of metaprogramming is its complicated syntax.
As the code is generated dynamically at runtime, there comes the issue of invisible bugs. The bugs come from the generated code, which is challenging to track and resolve. Sometimes, it becomes difficult to find the source and cause of the bug.
The execution of the computer program takes longer than usual because Python executes the new metaprogramming code at run time.

Metaclasses: The Foundation Of Metaprogramming

1. Metaclasses A Mechanism For Creating Classes Dynamically

A metaclass defines the behavior and structure of classes. Using metaclasses in Python, you can easily customize class creation and behavior. This is possible because Python represents everything, including the classes, as an object. Moreover, the object is created using the class. Therefore, this supposed "class" is act as a child class of another class that is metaclass a super class. In addition, all Python classes are child classes of metaclasses.

Note:

Type is the default metaclass in python. It is used to create classes dynamically.

2. Metaclass ‘new’ And ‘init’ Methods

In Python, metaclasses are by default "type" class i.e. base class which is used to manage the creation and behavior of classes. Upon creating the class in Python, we indirectly used the "type" class. The metaclass consists of two primary methods: __new__ and __init__. The __new__ method is used for creating a new object. This method creates and returns the instance, which is then passed to the __init__ method for initialization. It is called before the __init__ method and assures the control creation of the class itself. Then, the __init__ method is used after the creation of new class to initialized it with furthur attribute and methods. This method is quite different from the regular programming method. It allows us to modify and set the class-level attributes after class creation.

Tip:

new and init methods are used for creating the custom classes and its behavior

3. Example: Creating Custom Metaclasses To Customize Class Creation Behavior

Let's understand with a simple python example how we can create custom metaclasses to customize the class creation and its behavior using the metaclass primary methods __new__ and __init__.

# Define the metaclass
class Meta(type):
    #define the new method for creating the class instance
    #cls: metaclass whose instance is being created
    #name: name of the class #base: means the base class
    #class_dict: represent the dictionary of attributes for a class
    def __new__(cls, name, bases, attrs):
        #making the attributes(method) name as upper case
        uppercase_attrs = {key.upper(): value for key, value in attrs.items() if not key.startswith('__')}
        new_class = super().__new__(cls, name, bases, uppercase_attrs)
        print("Class {name} has been created with Meta")
        return new_class

    #the class is initialized
    def __init__(cls, name, bases, dct):
        super().__init__(name, bases, dct)
        print(f"Class {name} initilized with Meta")

# Using the metaclass in a new class
class MyClass(metaclass=Meta):    
    def my_method(self):
        print(f"Hello!")

# Instantiate MyClass and access its custom attribute
obj = MyClass()
#here the attribute of the class is change into uppercase i.e. the name of method
obj.MY_METHOD()

Output

Note:
Remember that in the output, the "Hello" string will not be converted into uppercase, but the method name 'my_method' as 'MY_METHOD' that will print the string. This means that we are converting the name of the method into uppercase.

Decorators: Metaprogramming At The Function Level

1. Decorators As Functions That Modify The Behavior Of Other Functions

Decorators are the key features of Python metaprogramming. Decorators are a powerful feature that allows developers to modify existing code without changing the original source code. It allows you to add new functionality by extending the existing function. Decorators are typically performed on functions, and their syntax uses the “@” symbol with the decorator function name before its code. In Python, decorators act as a wrapper around other functions and classes. The input and output of the decorator are the function itself, typically executing functionality before and after the original function.

2. Syntax Of Decorators

Decorators use the @decorator_name as a syntax. Whereas the decorator_name is the name of the function that you make as a decorator.

@decorator_name 
def function_name():

The syntax is also used as following, which shows the decorator taking a function as an argument and save the result into another function.

Function_name = decorator_name(function_name)

3. Illustration of creating and using decorators to add functionality to functions

Below is an example of using decorators to convert the string of one function into uppercase, which means adding the uppercase functionality to the function:

#function for converting the string into upercase
def my_decorator(function): 
    #function within a function
    def wrapper(): 
        #here, we call the decorator function inside this function
        func = function() 
        #converting the string
        upper_Case = func.upper() 
        return upper_Case
    return wrapper

@my_decorator
def get_String(): #getting the string for converting in upper case
    return "Actions speak louder than words"
print(get_String()) #printing the string

Output

The 'inspect' Module: Introspection And Reflection

1. Introduction To The `Inspect` Module For Introspection And Reflection

In the metaprogramming world, inspection and reflection are key terms. Inspection is performed to examine the type and property of an object in a program and provide a report on it at runtime. In contrast, reflection involves modifying the structure and behavior of an object at runtime. These two language features make python a strongly typed dynamic language. We can perform inspection and reflection in metaprogramming using the "inspect" module. This module provides various functions for introspection, including information about the type and property of an object, the source code, and the call stack.

2. How To Use The 'inspect' Module To Examine And Modify Objects At Runtime

Let's understand that using the "inspect" module for introspection and reflection combined with other Python features, we can examine and modify the object at run time in metaprogramming. We will learn it step by step:

1. Examine The Object Using "inspect" Module

#import inspect module
import inspect

#create a class name person
class Person:
    #setting the class attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    #generating a function
    def greet(self):
        return "Name is {self.name} and Age is {self.age}"

person = Person("Harry", 26)

# Get the class of the object
print("Class of obj:", inspect.getmembers(person.__class__))

# Retrieve all members of the object
print("Members of obj:", inspect.getmembers(person))

#Print the source code
print("Source code of MyClass:")
print(inspect.getsource(Person))

#Print the documentation string
print("Docstring of MyClass:", inspect.getdoc(Person))

Output

2. Modifying The Object At Runtime

#import inspect module
import inspect
import types

#create a class name person
class Person:
    #setting the class attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    #generating a function
    def greet(self):
        return "Name is {self.name} and Age is {self.age}"

person = Person("Harry", 26)

# Add a new attribute
setattr(person, 'new_attribute', 42)
print("New attribute value:", person.new_attribute)

# Modify an existing attribute
setattr(person, 'name', "Henry")
print("Modified name:", person.name)

# Add a new method dynamically
def myfunc(self):
    print("My age is {self.age}")

setattr(Person, 'myfunc', myfunc)  # Attach the method to the class

# Call the new method
print("New method output:")
person.myfunc()

Output

This is how you can examine and perform modification dynamically at run time. Using the inspect module combined with Python's built-in functions like setattr and delattr will allow the developer to write flexible and adaptive that can change at runtime.

Tip:

Both setattr and delattr are Python functions for dynamically changing object attributes. In these functions, setattr is used to set and alter the attribute, and delattr is used to delete the attribute from an object.

3. Practical Use Cases For Introspection And Reflection

Debugging And Code Analysis

As we know, debugging is quite more hectic and time-consuming than writing the code the first time. Developers debug the code to verify and find the sources of defects to handle them at the early stages. However, it is a very heterogeneous process when we cannot identify its source. Therefore, introspection and reflection are very useful for debugging the code. It examines the object dynamically at run time by providing the details of the object’s nature, including its behavior. It provides the details of object attribute values and unexpected values and explains how the state of the object changes over time. To make this clearer, let's use an example.

#import inspect module
import inspect

#create a class name person
class Person:
    #setting the class attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    #generating a function
    def greet(self):
        return "Name is {self.name} and I am {self.age} years old."

person = Person("Harry", 26)

# inspecting attribute
print("Object Attribute:", dir(person))
print("Value of Attribute:", person.name, person.age)

#Add new attribute for debugging
setattr(person, 'debug_info', "Henry")
#print debug info like this
print("Debug Info", person.debug_info)

Output

Wrapping Up

To sum up, we discussed the Python advanced concept, which is metaprogramming. As we know, metaprogramming is the techniques that extend and modify the behavior of the Python language itself. It can help you write functions that can modify and generate other functions.. We can perform metaprogramming using different approaches like metaclasses allows us to use the default type class and then the decorator, which acts as the wrapper to another function and shifts towards the techniques to debug the code beforehand. So, wherever you are moving towards Python advanced concepts, do not forget to learn about metaprogramming significance as well. I hope this guide is helpful to you. Thank you for reading. Happy coding!

Additional Reference

Python Inspect Module

MetaClasses in Python

Decorators

Python Code Reviews and Collaboration Best Practices and Tips

CoderLegion — Sat, 30 Nov 2024 22:44:07 +0000

🎉 Before you dive into this article...

🚀 Check out our vibrant new community at CoderLegion.com!

💡 Share your knowledge, connect with like-minded developers, and grow together.

👉 Click here to join now!

Are code review and collaboration the secret elements for building better software? While working on software development, better quality is super crucial. What if I told you that the secret is not about writing good code, but how to review it, and incorporate collaboration for consistent feedback? Yes, code review will not only help us find bugs and errors in the code but also refine the development process. It is important to embrace code review because it makes the software high quality. As a senior developer, it is your responsibility to conduct code review and provide constructive feedback to your peers. Therefore, code review is significant for enhancing software quality, adhering to the best practices, and promoting a collaborative development environment.
Therefore, in this article, I will cover the importance of code review and how you can enhance your development process through collaboration. As well as best practices of Python for code review and effective ways of providing feedback to your peers.

Understanding the Role of Code Reviews

Code Reviews in Software Development Lifecycle

The SDLC consists of several steps through which an application undergoes development. As development progresses, code review becomes essential. This is a quality assurance process in which the reviewer analyzes the developer's written code before moving on to the testing phase. It typically falls in the "verification and validation" phase of SDLC to ensure that the software functionalities are based on defined requirements. Furthermore, it validates the correctness, enhances the quality, and improves the maintainability of your code before releasing it to the user.

Note:

The Software Development Life Cycle (SDLC) is a process that consists of the steps involved in the development of software, from initial requirements to deployment and maintenance.

Benefits of Code Reviews

Testing is the phase that follows the development phase, in which the tester verifies the software application against the requirements. However, what is the need for code review when we have the testing phase? Therefore, learn the countless benefits of incorporating code review that will clarify why code review is necessary:

Improving Code Quality: It lets you improve the quality of software applications by following the predefined coding rules and standards. By using code review, managing the quality becomes easier, and you can maintain the code for long use.
Identifying Bugs: It lets you catch the bugs and errors at the early stages of development. During the testing phase, we detect all the mistakes of the software application, but it takes a lot of time. Therefore, code review helps you to uncover all the errors during the application development and maintains the quality of code.
Sharing Knowledge: It lets you learn new skills and concepts by sharing information and ideas related to the projects between peers. Code review follows the collaborative environment where all the team members work team to find the most effective solutions to meet the client's needs.

Establishing a Positive Code review Culture Within the Development Team

To establish a positive culture that would be seen as collaborative but not judgmental. Create a guideline before starting a code review process, that emphasizes constructive feedback, encouragement, and acknowledgment of some effort rather than a critique of their abilities.

Set Clear Goals and Objectives: Before starting the review process, define the goals and prioritize the important metrics. The goals include the verification of defined standards for writing the code. Then, focus on the functionality, readability, and performance of the application.
Use a Code Review Checklist: One good strategy for code review is creating a well-defined checklist. The checklist is based on the application's functional requirements to make sure that all the aspects are covered for review and that nothing is missed.
Encourage Active Participation: Construct an environment that allows all members to actively participate in project discussion. This way, the team will collaborate efficiently by getting diverse perspectives and different ideas from each member, which would encourage knowledge sharing as well.
Regular Reviews: Divide the review process into multiple iterations where the reviewer can focus on multiple aspects like code logic, its design pattern, etc. Furthermore, scheduling the regular code review sessions would maintain code quality and catch issues early.
Use Code Review Tools: Utilize tools like GitHub's pull request feature or Code Collaborator for efficient code reviews. Also, the use of code review tools like linters, and some IDE plugins will help to automate the code review process.
Pair Programming: Always try to break down large changes into smaller ones to make manageable chunks for more effective reviews. Furthermore, you can incorporate pair programming methods which allow immediate feedback discussion, and review in real-time simultaneously.
Provide Constructive Feedback: After completing the code review, it is preferred to offer feedback that is specific, actionable, and focused on improving the code.

Setting Guidelines and Standards for Code Reviews

Several guidelines and standards are defined by the industry, which senior tech developers implement or follow while performing code reviews on their peer's work. This includes verification of the code design, its style, module complexity, naming conventions, and the following testing criteria. Therefore, these guidelines help developers to follow a structured approach.

Defining Clear Criteria for Code Review Feedback

Developers working on the project are not just coding what comes to their mind, but there is some defined functionality that the system must perform. The reviewer begins with the basic steps to verify the application functionality. To check, is there any functionality missing? Or are the functionalities properly implemented?

Furthermore, when the senior developer reviews the code functionalities, the next step is to check the readability of the program code. Asking that, is the code easy to understand. If the new developer starts working on the project, is it understandable enough for the one to start coding without any confusion? Also, are all modules working independently? The most frequently asked question is whether the new changes can be easily incorporated. These questions need to be clarified before deployment. Therefore, beyond meeting user requirements, clean and easy-to-understand code is also necessary.

Additionally, the code reviewer must also check the performance of the system. Sometimes the program consumes more resources of the platform than its speed. Therefore, balancing these factors can make the program robust, which is only done when followed in the correct strategy. So, a developer can ask the following questions: Is the program affecting the performance of other applications? Or will the program negatively impact the overall system performance?

Adopting Coding Standards and Best Practices to Ensure Consistency

Python has defined coding standards and best practices that help ensure code consistency and maintainability. PEP 8 is the style guide provided for writing Python code. This guide includes all Python conventions and practices required to write efficient and understandable code. By adopting PEP 8, you will be able to write maintainable code. Ensuring consistency is the crucial aspect of code review feedback. It includes descriptive and consistent names of variables, function classes, and other elements used in the program and ensures correct indentation, spacing, and line length for consistent formatting throughout the code.

Conducting Effective Code Reviews

Techniques for Reviewing Code Efficiently and Thoroughly

Now that you understand the role of a code review and what to look for in a code review. Here, I will list the effective tips and techniques for conducting code reviews:

1. Over-the-Shoulder Review

This is known as synchronous code reviewing, in which the developer writes the code, and then the reviewer reviews it. The reviewer joins the developer and suggests changes over the shoulder. It is an informal technique implemented by 75% of companies. This technique is faster than the other, but it lacks an in-depth review of the code.

2. Pair Programming

In pair programming, two developers work simultaneously on the same computer. One develops the code, and the other is the navigator who reviews the code and provides inline comments. In these techniques, immediate feedback is provided along with proposed improvements. This technique has many uses such as collaboration, code quality improvement, and facilitation of knowledge sharing among members.

3. Email-Based Code Review

These techniques involve sending code snippets via email to team members for review and feedback. The developer writes the code and sends the code screenshots to the reviewer via email. The reviewer verifies the code and provides feedback and suggestions via email replies or inline comments within the code snippets.

4. Meeting-Based Code Review

In a meeting-based code review, all team members gather in person or through online meetings to discuss the code changes and needed improvements. The developer explained the code and the approach he used with the challenges he faced, whereas the other members proposed the changes and provided feedback for improvement in the meeting.

5. Tool-Based Code Review

This technique involves the use of automated tools to perform the review process. These tools also have many uses, including code analysis, inline commenting, and version control integration that saves a lot of time for manual work.

Caution:

Don't rush the code review process. Taking enough time to go through a thorough review can prevent issues from being introduced into the codebase.

Providing Constructive Feedback and Actionable Suggestions for Improvement

Be Specific: Highlight the piece of code where improvement is necessary. The reviewer must specify the module where improvement is required and provide constructive feedback on what needs to be improved.
Focus on Impact: Upon recommending an improvement, it is important to briefly explain the impact of the improvements. This would help the programmer focus on the impact as it would improve the code quality and performance of the system to make it maintainable.
Offer Solutions: The construction feedback should include suggestions or solutions to help the developer address the issue instead of just highlighting the problems. Therefore, the reviewer should try to provide an alternative way of resolving the issue.
Use Positive Reinforcement: Encourage the developer where good practice is used as this positively impacts the developer's work. So, try to acknowledge the positive aspects of the code in maintaining a friendly and productive collaboration environment.
Follow-up: Keep the document tailored to previous feedback to track progress and ensure that the suggested improvements are incorporated or not.

Tip:

Code review feedback should be constructive and aimed at improving the codebase. Provide feedback positively and helpfully.

Using Code Review Tools and Integrations to Streamline the Review Process

To automate tasks and ensure consistency, some code review tools can significantly streamline the review process. Select the right tool that best suits your needs or preferences. There are many tools available, each of which has its own features and advantages. These tools use a structured approach to review the code. These are:

Review Board is an open-source web-based tool for streamlining the code review process. It supports various version control systems like Git or Subversion. It provides the features of inline commenting, issue tracking integration, and extensibility through plugins. Furthermore, it also shows a visual comparison of the changes in your code. Another feature provides audit management and bug tracking.
Collaborator is another tool provided by Smartbear. It is a code and document review tool for development teams. It also provides support to version control systems like git, mercurial, etc. You can also integrate it with project management tools, including Jira and Visual Studio.
pylint is an automated code analysis tool that automatically checks for syntax issues, common errors, or bugs and enforces the coding standards. It provides feedback based on defined standards and practices.
Another tool for conducting code reviews involves integration with a version control system, in which the code is stored and accessed by all members. It includes GitHub. GitLab and Bitbucket encourage code review within the development workflow. GitHub is an inbuilt code review tool, but it only supports Git repositories.
Furthermore, utilizing the automated code analysis tools with the CI/CD pipeline will automatically review the code before merging the changes, which helps in preventing errors from reaching production.

Collaborative Problem-Solving in Code Reviews

Encouraging Collaboration and Knowledge Sharing during Code Reviews

Ask Questions: To encourage collaboration and knowledge sharing within a team, ask as many questions as possible. These questions will help you clarify doubts related to the code, its design, and other logic. Sometimes, a question will spark more discussion and suggestions. While asking, avoid using a sarcastic tone and be respectful and curious.
Share Tips and Resources: While suggesting changes, you can share tips and resources as well, which will help the reviewer and the developer improve their skills and productivity. You can share useful libraries that you know or some blogs and books.
Coding Examples: Use a coding example during collaboration to explain your point of view. This will provide a clear view to the reviewer about your point and a comparison of different solutions with distinct approaches.

FAQs

<strong>Q:</strong> What is a good code review?<br>
<strong>A:</strong> A good code review approach covers all aspects including code correctness, test coverage, and functionality changes, and follows the coding guides and best practices.

Wrapping Up

In conclusion, we discussed that effective code review is not just about checking the code but also about quality control mechanisms. Implementing code review before the testing phase will improve the developer's skills, promote collaboration, and provide continuous improvements. We also learned how to establish a positive culture for reviewing the code, which includes defining a clear objective, encouraging participation, and providing constructive feedback to enhance the review process. In addition, different techniques are used to conduct code review, but it is important to select the right approach to make a robust application. I hope this guide is helpful for you. If you have any questions or concerns, then feel free to give feedback. Thank you for reading this guide. Happy Coding!

Reference

PEP 8 Style Guide
GitHub Code Review Process Guide
Book: Effective techniques to improve collaboration within Python development

Tkinter library in Python

CoderLegion — Fri, 22 Mar 2024 14:00:00 +0000

In this article, we'll dive into the world of Graphical User Interface (GUI) development using Python's Tkinter library. Tkinter stands as a versatile and user-friendly tool for beginners and advanced programmers alike, simplifying the creation of GUI applications. We aim to demystify the process of working with Tkinter, from understanding its core widgets to leveraging its strengths and navigating its limitations. By the end, you'll be equipped with the essentials of Tkinter to enhance your Python GUI development projects.

Understanding Tkinter

Tkinter, short for Tk interface, is a built-in Python library designed for creating interactive GUI applications. Tkinter, built on the Tk GUI toolkit, streamlines the creation of windows, buttons, menus, and other graphical elements. As an integral part of the Python standard library, Tkinter smoothly integrates with Python projects, requiring no extra installations, for a seamless GUI development experience. The official python tkinter documentation offers in-depth explanations of Tkinter modules, classes, and methods. Visit Documentation

Tip: As you embark on your GUI development journey, start by sketching out the design and functionality of your application before jumping into the code. This can save time and streamline your development process.

Exploring Basic Widgets

We'll begin by exploring some fundamental components you can construct using Tkinter. The following snippets must be preceeded by:

import tkinter as tk
window = tk.Tk()
window.geometry("457x335")

and followed by:

window.mainloop()

Caution: When working with widgets, remember to assign a unique name to each widget variable to avoid confusion, especially when your application starts to grow.

Label

Presents either text or an image, lacking interactive features for users. For more information on label refer official documentation of python.

label = tk.Label(window, text="This is a Label")
label.pack()

Button

An interactive component that executes a specific operation upon being clicked, like dispatching form data or activating a particular function.

def button_click():
    print("Button clicked")

button = tk.Button(window, text="Click here!", command=button_click)
button.pack()

After clicking the button:

Entry

A text field where users can input text or numbers. This component is frequently utilized for entering information or executing search operations.

entry = tk.Entry(window)
entry.pack()

Text

A text field that provides a multi-line text editing area for users to input or display text.

text = tk.Text(window, height=5, width=30)
text.pack()

Scale

Enables users to choose a value from a spectrum by moving a slider control. It is useful for selecting values like volume, brightness, etc.

def update_value(value):
    label.config(text=f"Volume Level: {value}")

scale = tk.Scale(window, from_=0, to=100, orient=tk.HORIZONTAL, command=update_value) #create a scale to select values from 0 to 100

scale.pack()
label = tk.Label(window, text="Volume Level: ")
label.pack()

Spinbox

A numerical input field with up and down arrow buttons for incrementing or decrementing the value.

spinbox = tk.Spinbox(window, from_=0, to=10)
spinbox.pack()

Separator

A horizontal or vertical line to visually separate sections or groups of widgets.

from tkinter import ttk #for themed widgets

label_1 = tk.Label(window, text="This is above the separator.")
label_1.pack()

separator = ttk.Separator(window, orient=tk.HORIZONTAL)
separator.pack(fill=tk.X)

label_2 = tk.Label(window, text="This is below the separator.")
label_2.pack()

Checkbutton

A checkbox enabling users to toggle between selecting and deselecting an option.

check_var = tk.BooleanVar() #To keep track of the checkbox's state (checked or unchecked)
check_button = tk.Checkbutton(window, text="Checkbox", variable=check_var)
check_button.pack()

Radiobutton

A group of radio buttons, ensuring that users can select only one option from a list of choices.

radio_var = tk.StringVar() #To track which radio button is selected
radio_1 = tk.Radiobutton(window, text="Option 1", variable=radio_var, value="Option 1")
radio_2 = tk.Radiobutton(window, text="Option 2", variable=radio_var, value="Option 2")
radio_1.pack()
radio_2.pack()

Listbox

A widget presenting a list of items, allowing users to select one or more options from the list.

Scrollbar

Permits users to navigate through content surpassing the widget's visible boundaries, like in a text field or list.

listbox = tk.Listbox(window)
scrollbar = tk.Scrollbar(window)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y) #scrollbar will be at the right side of the window and expands vertically
listbox.pack(side=tk.LEFT, fill=tk.BOTH) #listbox will be at the left side of the window and expands horizontally and vertically
listbox.config(yscrollcommand=scrollbar.set) #Attach scrollbar to listbox
scrollbar.config(command=listbox.yview)

for i in range(30):
    listbox.insert(tk.END, f"Item {i+1}")

ColorChooser

A dialog for users to select a color. It provides a graphical interface for choosing colors using a palette or entering RGB values.

from tkinter import colorchooser

def choose_color():
    color = colorchooser.askcolor()
    print("Selected color:", color)

button = tk.Button(window, text="Choose Color", command=choose_color)
button.pack()

Frame

A container used to group and organize other widgets. It is frequently used for layout purposes, creating sections or divisions within a window.

frame = tk.Frame(window, bg="lightblue", bd=5)
frame.pack()

label = tk.Label(frame, text="Inside the Frame", bg="lightblue")
label.pack()

Canvas

Provides a drawing area for creating graphics, shapes, and custom elements. It is used for creating diagrams, charts, and interactive visualizations.

canvas = tk.Canvas(window, width=200, height=100, bg="white")
canvas.pack()
canvas.create_rectangle(50, 25, 150, 75, fill="red") #draw a red-coloured rectangle

PanedWindow

A container for arranging multiple panes or frames with adjustable sizes. It allows users to resize panes by dragging the divider between them.

paned_window = tk.PanedWindow(window, orient=tk.HORIZONTAL)
paned_window.pack(fill=tk.BOTH, expand=True) #will expand both horizontally and vertically
frame1 = tk.Frame(paned_window, width=228, height=200, background="red")
frame2 = tk.Frame(paned_window, width=228, height=200, background="blue")
paned_window.add(frame1)
paned_window.add(frame2)

After dragging the divider to the left:

def print_something():
    print("You chose the first option")

menu_bar = tk.Menu(window)

file_menu = tk.Menu(menu_bar, tearoff=0)
file_menu.add_command(label="Print Something", command=print_something)
file_menu.add_separator()
file_menu.add_command(label="Exit", command=window.quit)
menu_bar.add_cascade(label="Click to see options", menu=file_menu)
window.config(menu=menu_bar)

After selecting "Print Something":

These elements serve as fundamental components for Tkinter GUI applications, frequently employed across diverse projects to develop intuitive interfaces.

To delve deeper into Tkinter and explore its capabilities, you can start with the following sections of the Python documentation:

Tkinter — Python interface to Tcl/Tk: This section provides the foundational knowledge required to create GUI applications with Tkinter, including widget classes, event handling, and more Python Tkinter Documentation.
Graphical User Interfaces with Tk: This part of the documentation discusses the integration of Tk/Tcl with Python, offering insights into the architecture of Tkinter applications, the Tkinter module, and thematic widget extensions Python GUI with Tk.
Tkinter.ttk — Tk themed widgets: For those interested in using themed widgets for a more modern GUI look, this section details the thematic widget set provided by Tk 8.5 and integrated into Tkinter Themed Widgets.

Conclusion

Tkinter is a versatile and user-friendly toolkit for Python GUI development, offering a rich set of widgets, cross-platform compatibility, and seamless integration with Python code. Despite its limitations, Tkinter remains a popular choice for developers looking for efficient creation of simple to moderately complex GUI applications.

How to create an Empty Vector in C++?

CoderLegion — Wed, 01 Mar 2023 07:04:34 +0000

While storing data in our programming the first thing what comes in mind of a programmer is array. Arrays are one dimensional as well as multi-dimensional (2D arrays …..) so arrays are best for storing data but there is a limit for arrays to store data and the programmer needs to specify size of array before storing data at time of creation of array.
Here to solve this huge problem, we use vectors. Vectors allow us to store unlimited amount of data (until our ram capacity is free). Vectors are helpful because they keep updating on storage of data and keep increasing their size. We can say that vectors manage their size themselves.
Vector is a part of STL(standard template library) which may also be called dynamic arrays.
In order to create an empty vector, first of all you need to include header file named vector. You can include that as follows:

include

Then in the function where you want to use vector, you can create is by specifying datatype of vector and vector name as follows:

vector vectorName;
The data type can be int , double, string or char and for vector name all rules for variable naming apply.
So here is a C++ program to create an empty vector of integers.

include //Include input output stream

include //Including vector header file which allows us to use vectors

using namespace std; //using standard namespace
int main(){
Vector v;
Return 0;
}
Now the vector is created. If you want to add the data in vector you can do this by using function push_back(data). So in the vector we created we will add some values.

include

using namespace std;
int main(){
vector v;
v.push_back(5);
v.push_back(10);
v.push_back(2);
return 0;
}
The above code will create vector and will add 5, 10 and 2 in the vector. Consider it an array where we have first element at index 0 , second at index 1 and so on.
So we have 5 at index 0 , 10 at index 1 and 2 at index 2;
In order to access data from vector, we can do it like we do in array.

include

using namespace std;
int main(){
vector v.push_back(5);
v.push_back(10);
v.push_back(2);
cout< cout< return 0;
}
Like this we can create and use a vector in C++.
In order to study more about vectors you can check 8thesource for more such topics

Make the code wait for page load in python

CoderLegion — Fri, 17 Jun 2022 23:42:02 +0000

Introduction
This article will teach you to make your code wait for page load in python. In fact, if you are trying to make the code wait for the website to load all elements in it, this article should help you. You will learn libraries that play a vital role in web scraping.

Table of contents
How to make the code wait for page load in python
Solution 1
Solution 2
Solution 3
Solution 4
In general
Conclusion
How to make the code wait for page load in python
There are multiple solutions to this. We will use requests_html, requests, urllib and selenium in these solutions.
Requests HTML is a library that makes HTML parsing (for example, web scraping) as simple as possible.
For the Python programming language, Requests is an HTTP library. The project's purpose is to make HTTP requests more human-friendly and straightforward. Version 2.27.1 is the most recent release. The Apache License 2.0 applies to Requests. One of the most widely-used Python libraries is Requests. Queries make it very simple to send HTTP/1.1 requests. There's no need to manually add query strings to your URLs or form-encode your PUT and POST data – use the JSON method any more! Requests is one of the most popular Python libraries today, with over 30 million downloads per week— according to GitHub, over 1,000,000 repositories rely on Requests. You can put your faith in this code without a doubt. urllib is a package that contains numerous URL-related modules: Selenium is an open-source umbrella project that includes several browser automation frameworks and applications. It provides a replay tool that allows you to create functional tests without learning a test scripting language. The Selenium Python bindings offer a straightforward interface for developing Selenium WebDriver available and acceptability tests. You can use the Selenium Python API to quickly and naturally access all of Selenium WebDriver's functionality. The Selenium Python bindings give you a straightforward way to interface with Selenium WebDrivers like Firefox, Internet Explorer, Chrome, and Remote. Python versions 3.5 and higher are supported at the moment.
Solution 1
from requests_html import HTMLSession
s = HTMLSession()
response = s.get(url)
response.html.render()
print(response)
Solution 2
from bs4 import BeautifulSoup
from selenium import webdriver
url = “the url”
browser = webdriver.PhantomJS() browser.get(url)
html = browser.page_source
soup = BeautifulSoup(html, 'lxml')
a = soup.find('section', 'wrapper')
Solution 3
import urllib.request
try:
with urllib.request.urlopen(url) as response:
html = response.read().decode('utf-8') #use whatever encoding as per the webpage
except urllib.request.HTTPError as e:
if e.code==404:
print(f"{url} is not found")
elif e.code==503:
print(f'{url} base webservices are not available') ## can add authentication here
else:
print('http error',e)
Solution 4
r = requests.get('https://github.com', timeout=(3.05, 27))
In general
We should use selenium to click button on webpage using python.

Conclusion
The most straightforward methods to make your code wait for page load in python are requests_html, requests, urllib and selenium. Also, most of them simulate real website user behaviour making them load most of the sites completely.

Sdk location not found. define location with sdk.dir in the local.properties

CoderLegion — Fri, 17 Jun 2022 23:40:47 +0000

If you've ever come across the following error message in your Android Studio project, you know it's not exactly helpful: 'SDK location not found. Define location with sdk.dir in the local.properties file or with an ANDROID_HOME environment variable.' Well, this post will tell you how to fix that problem (and explain what the problem is!).

Photo by Irina_kukuts
Table of Content:
1 - What is Sdk location not found. Define location with sdk.dir in the local.properties
2 - Why will this message appear
3 - What is the solution
4 - The Conclusion

What is Sdk location not found. Define location with sdk.dir in the local.properties
A Software Development Kit (SDK) is a set of tools that may be used to create software. SDK is a collection of tools that allow you to write programs for mobile platforms like Android and iOS. You can download the SDK from: https://developer.android.com/studio/releases/platform-tools and extract/place it in the default folder if one does not exist. The SDK's default location on a Windows PC would be

sdk.dir = C:\Users\UserName\AppData\Android\sdk (here username is the name of your PC)
If you run into this issue, it's likely because the sdk.dir property is not set to an actual SDK location.

This could be due to a number of factors:

The sdk.dir property is not defined at all. If you don't have a local.properties file in your project directory, you'll need to create one and define the sdk path in it like so:

sdk.dir = C:\Users\UserName\AppData\Android\sdk (here username is the name of your PC, if sdk is not installed on root )
Why will this message appear
There may be a number of errors in the code while writing a program or in a project setting, which may be due to the same or different reasons. In this case, the following reasons may be present

The path is not set to local.properties file in the project.
Local.properties file is missing in the project folder
An environment variable is not set to your sdk path.
There may be multiple lines local.properties file that also can throw this error message.
What is the solution
It is possible that the different causes that make up an error message all have the same solution and it is also possible that there are different solutions for the same cause.

If the path is not set in the local.properties file needs to be set it. You can find this file in your SDK directory under the resources folder.
If local.properties does not exist, you will need to create it. You can find this file in your SDK directory under the resources folder. To create local.properties, all you have to do is open a new file in any text editor and rename it with a ~ at the beginning of its name (local~). Then add this code:
sdk.dir=/path/to/sdk/folder (locate your sdk folder and write its path here)
ANDROID HOME should be added to the Environment Variables list. Add a variable by going to System Properties -> Environment Variables -> Add Variable and entering the Variable Name and Value. Add ANDROID HOME as a variable with the value: as your SDK path. If your route isn't in C Drive, you'll need to include the write path for sdk. Make sure you're on the right track. The name of your computer is UserName. and then click OK.

sdk.dir=/path/to/sdk/folder (locate your sdk folder and write its path here)
The file should contain only one line: sdk.dir=path_to_your_android_sdk . If you have multiple lines, it will create errors. The path is the location of your Android SDK folder which by default is in C:\Program Files\Android\Android Studio v3\sdk (for Windows) or /Applications/Android Studio v3/sdk (for macOS).
If you don't have an Android SDK installed and configured then download one from here: https://developer.android.com/studio/releases/platform-tools

The Conclusion
Mistakes are good for learning, only those who learn from mistakes are successful. There is an old saying that those who learn from their mistakes are good and successful persons but those who learn from the mistakes of others are not only good and successful but also very good and superman.

You Don't Have Write Permissions For the /library/ruby/gems/2.3.0 Directory

CoderLegion — Fri, 17 Jun 2022 23:38:30 +0000

Have you tried to install a Ruby gem (like Rails, Jekyll, or cocoapods) and received a write permissions error? This is one of the most prevalent mistakes made by humans. If you try to install a gem on a Mac that hasn't been properly configured for Ruby development, you'll see this error.

Photo by Gaming_birder
Table of Content:
1 - Explanation of You Don't Have Write Permissions For the /library/ruby/gems/2.3.0 Directory
2 - Reasons for the Appearance of This Message
3 - The Solution
4 - The Conclusion

Explanation of You Don't Have Write Permissions For the /library/ruby/gems/2.3.0 Directory
If you've installed a Ruby via Homebrew and you go to do a gem install, you might see this error:gem install fyber-ruby-sdk -v '1.1.0'ERROR: While executing gem ... (Gem::FilePermissionError)You don't have write permissions into the /Library/Ruby/Gems/2.3.0 directory.

You don't have write permissions for the /library/ruby/gems/2.3.0 directory. This is a common error message when trying to install gems on a MacOS X system, and it can be frustrating to deal with if you don't know what's happening.

Reasons for the Appearance of This Message
A person can make a mistake during any task, It is not required for the error to be discovered right away. thanks to the computer which immediately identifies any mistake and notifies its user immediately. It is important to discuss the reasons for the mistake we are discussing. the reason to see this message you don't have write permissions for the /library/ruby/gems/2.3.0 directory is certain versions of Ruby, such as those found on macOS and Ubuntu, require elevated rights to install gems. When installing a gem without writing permissions this error message will appear.

The Solution
So, how do you install gems on a Mac the right way? The most reliable technique, and the only one I advocate, is to use a version manager to install a separate and newer version of Ruby. I strongly advise you to use Ruby version management since it allows you to install many versions of Ruby at the same time and makes switching between them a breeze. Even if you're new to Ruby, it's worth your time to learn how to use a Ruby manager since you'll need one eventually.

A functioning Ruby environment on macOS with a Ruby manager may be achieved in a minimum of five steps:

Homebrew should be installed (which will also install the prerequisite Apple command-line tools)

Use a Ruby version manager like chruby or ruby-install to manage your Ruby versions (others include rbenv, asdf, and RVM)

Set up Ruby's version management.

Install a certain Ruby version.

Change to that Ruby version.

It isn't limited to a single application. You may run it as often as you like to maintain your system secure and up to date. It can also save you half a day the next time you obtain a new Mac by automatically installing all of your Mac software as well as a complete development environment. For a one-time fee, you can benefit from all of these time savings now and in the future.

The Conclusion
This is the most common reason for you not being able to install a gem. If you ever see this error message, double-check your permissions and try again!

Forem: CoderLegion

[Boost]

The 2-Minute Technical Debt Killer That Saved My Team 200 Hours

Pratham naik for Teamcamp ・ Sep 23

Introducing CoderLegion, A Community for Coders, by Coders...

💡 Why CoderLegion Stands Out

🧪 Coming Soon: Developer Groups

🤝 Powered by Community Leaders

🌱 How You Can Get Involved

🧭 Built in the Open

Join the Fastest-Growing Developer Community

Join the Fastest-Growing Developer Community!

Join Now – It's Free!

Why Join?

Trusted by Thousands of Developers

How It Works

ThDatabase Interaction using Python: Introduction to SQLite/MySQL/PostgreSQLis is a test article

Create a cursor object

Advanced Python Concepts - Networking with Python

Introduction to Networking Concepts

1. Networking and Its Significance In Distributed Systems

2. Key Networking Concepts

2.1. IP Address

2.2. Port

2.3. Protocol

2.4. Sockets

3. OSI Model and The TCP/IP Stack

3.1. TCP/IP Stack

3.2. OSI Model

Socket Programming Basics

1. Socket Programming As The Foundation Of Networking In Python

2. Sockets As Endpoints For Communication Between Machines

3. Example: Creating and Using Sockets for Basic Network Communication

Working with TCP/IP

1. Transmission Control Protocol (TCP) And Its Role in Communication

2. Example: Creating TCP Client And Server Applications In Python

3. Building A Simple Chat Application Using TCP Sockets

Wrapping Up

Reference

Advanced Python Concepts - Metaprogramming

Understanding Metaprogramming

1. Metaprogramming And Its Role In Python

2. Metaprogramming And Regular Programming

3. Benefits And Risks Of Using Metaprogramming

Metaclasses: The Foundation Of Metaprogramming

1. Metaclasses A Mechanism For Creating Classes Dynamically

2. Metaclass ‘__new__’ And ‘__init__’ Methods

3. Example: Creating Custom Metaclasses To Customize Class Creation Behavior

Decorators: Metaprogramming At The Function Level

1. Decorators As Functions That Modify The Behavior Of Other Functions

2. Syntax Of Decorators

3. Illustration of creating and using decorators to add functionality to functions

The 'inspect' Module: Introspection And Reflection

1. Introduction To The `Inspect` Module For Introspection And Reflection

2. How To Use The 'inspect' Module To Examine And Modify Objects At Runtime

1. Examine The Object Using "inspect" Module

2. Modifying The Object At Runtime

3. Practical Use Cases For Introspection And Reflection

Debugging And Code Analysis

Wrapping Up

Additional Reference

Python Code Reviews and Collaboration Best Practices and Tips

Understanding the Role of Code Reviews

Code Reviews in Software Development Lifecycle

Benefits of Code Reviews

Establishing a Positive Code review Culture Within the Development Team

Setting Guidelines and Standards for Code Reviews

Defining Clear Criteria for Code Review Feedback

Adopting Coding Standards and Best Practices to Ensure Consistency

Conducting Effective Code Reviews

Techniques for Reviewing Code Efficiently and Thoroughly

1. Over-the-Shoulder Review

2. Pair Programming

3. Email-Based Code Review

4. Meeting-Based Code Review

5. Tool-Based Code Review

Providing Constructive Feedback and Actionable Suggestions for Improvement

Using Code Review Tools and Integrations to Streamline the Review Process

Collaborative Problem-Solving in Code Reviews

Encouraging Collaboration and Knowledge Sharing during Code Reviews

2. Metaclass ‘new’ And ‘init’ Methods