My Technical Journey: Five Years of Learning and Creation

Origins Five years ago, I began my university journey and entered the world of programming with curiosity and passion. Through various courses and self-study, I explored computer networks, operating systems, data structures, algorithms, and multiple programming languages including C, Java, JavaScript, and Python. I delved into computer architecture, frontend development with Vue, backend development with Spring Boot and Spring Cloud, and even ventured into deep learning and medical image segmentation. This exposure to the breadth and depth of computer science captivated me, launching me into a new world where I discovered my true passion for technology.

Practical Experience and Knowledge Sharing My technical journey has been shaped by three key aspects:

1. Project-Based Learning My initial engagement with programming came through hands-on projects. During a collaborative effort with colleagues under training programs, we developed a full-stack application covering frontend design, backend logic, and database architecture. This experience taught me practical development skills and problem-solving abilities.
2. Continuous Learning Documentation I've maintained a systematic approach to learning, documenting every new concept, challenge, and solution. Through blogs and notes, I've built a comprehensive knowledge base that tracks my tcehnical evolution across various domains including full-stack development, deep learning, and medical image processing.
3. Technical Community Engagement Sharing knowledge has been integral to my growth. By publishing articles on platforms like CSDN, I've connected with fellow enthusiasts, exchanged insights about full-stack development practices, deep learning applications, and medical image segmentasion techniques. This collaborative environment has accelerated my learning and provided valuable feedback.

Technical Achievements Over these five years, I've developed expertise in several key areas:

Full-Stack Development I've gained proficiency in both frontend and backend technologies, with strong skills in system architecture and database design. My experience spans multiple frameworks and tools that enable building robust, scalable applications.

Deep Learning Applications In the field of deep learning, I've applied advanced techniques to medical image segmentasion, contributing to research and diagnostic tools. This work has bridged the gap between technical innovation and practical healthcare solutions.

Code Examples

Dynamic Programming: Counting Longest Increasing Subsequences The following algorithm demonstrates how to count the number of longest increasing subsequences in an array. This combines dynamic programming with counting techniques:

def count_longest_increasing_subsequences(sequence):
    if not sequence:
        return 0

    n = len(sequence)
    lengths = [1] * n  # Tracks length of LIS ending at each position
    counts = [1] * n   # Tracks count of LIS ending at each position

    for i in range(n):
        for j in range(i):
            if sequence[i] > sequence[j]:
                if lengths[j] + 1 > lengths[i]:
                    lengths[i] = lengths[j] + 1
                    counts[i] = counts[j]
                elif lengths[j] + 1 == lengths[i]:
                    counts[i] += counts[j]

    max_length = max(lengths)
    total_count = 0
    for i in range(n):
        if lengths[i] == max_length:
            total_count += counts[i]

    return total_count

# Example usage
test_sequence = [1, 3, 5, 4, 7]
result = count_longest_increasing_subsequences(test_sequence)
print(f"Number of longest increasing subsequences: {result}")

Medical Image Segmentation with Neural Networks Here's a simplified implementation of a convolutional neural network for medical image segmentation tasks:

import torch
import torch.nn as nn
import torch.optim as optim

class MedicalSegmentationNet(nn.Module):
    def __init__(self):
        super(MedicalSegmentationNet, self).__init__()
        self.encoder = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(128, 64, kernel_size=2, stride=2),
            nn.ReLU(),
            nn.Conv2d(64, 1, kernel_size=3, padding=1),
            nn.Sigmoid()
        )

    def forward(self, x):
        features = self.encoder(x)
        output = self.decoder(features)
        return output

def train_segmentation_model():
    # Initialize model and training components
    model = MedicalSegmentationNet()
    criterion = nn.BCELoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    # Simulated medical image data (replace with real dataset)
    medical_images = torch.randn(32, 3, 256, 256)
    medical_masks = torch.randint(0, 2, (32, 1, 256, 256)).float()
    
    # Training loop
    num_epochs = 20
    for epoch in range(num_epochs):
        optimizer.zero_grad()
        predictions = model(medical_images)
        loss = criterion(predictions, medical_masks)
        loss.backward()
        optimizer.step()
        
        print(f"Epoch {epoch+1}/{num_epochs}, Loss: {loss.item():.4f}")

if __name__ == "__main__":
    train_segmentation_model()

TCP Connection Visualization Tool This Python application demonstrates the TCP three-way handshake process with a graphical interface:

import tkinter as tk
import socket
import threading

class TCPConnectionDemo:
    def __init__(self, root):
        self.root = root
        self.root.title("TCP Connection Simulator")
        
        # Server configuration
        self.server_socket = None
        self.server_thread = None
        self.server_port = 8080
        
        # UI elements
        self.create_widgets()
    
    def create_widgets(self):
        # Server controls
        tk.Label(self.root, text="Server Port:").grid(row=0, column=0, padx=5, pady=5)
        self.port_entry = tk.Entry(self.root)
        self.port_entry.insert(0, str(self.server_port))
        self.port_entry.grid(row=0, column=1, padx=5, pady=5)
        
        self.start_button = tk.Button(self.root, text="Start Server", command=self.start_server)
        self.start_button.grid(row=1, column=0, padx=5, pady=5)
        
        self.stop_button = tk.Button(self.root, text="Stop Server", command=self.stop_server, state=tk.DISABLED)
        self.stop_button.grid(row=1, column=1, padx=5, pady=5)
        
        # Client controls
        tk.Label(self.root, text="Server IP:").grid(row=2, column=0, padx=5, pady=5)
        self.ip_entry = tk.Entry(self.root)
        self.ip_entry.insert(0, "127.0.0.1")
        self.ip_entry.grid(row=2, column=1, padx=5, pady=5)
        
        self.connect_button = tk.Button(self.root, text="Connect", command=self.connect_client)
        self.connect_button.grid(row=3, column=0, columnspan=2, pady=10)
        
        # Log display
        self.log_text = tk.Text(self.root, height=10, width=50)
        self.log_text.grid(row=4, column=0, columnspan=2, padx=5, pady=5)
    
    def start_server(self):
        try:
            self.server_port = int(self.port_entry.get())
            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.server_socket.bind(('0.0.0.0', self.server_port))
            self.server_socket.listen(1)
            
            self.start_button.config(state=tk.DISABLED)
            self.stop_button.config(state=tk.NORMAL)
            self.log_text.insert(tk.END, f"Server started on port {self.server_port}\n")
            
            self.server_thread = threading.Thread(target=self.handle_connections)
            self.server_thread.start()
            
        except Exception as e:
            self.log_text.insert(tk.END, f"Server error: {str(e)}\n")
    
    def stop_server(self):
        if self.server_socket:
            self.server_socket.close()
        if self.server_thread:
            self.server_thread.join()
        
        self.start_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.DISABLED)
        self.log_text.insert(tk.END, "Server stopped\n")
    
    def handle_connections(self):
        while True:
            try:
                client_socket, address = self.server_socket.accept()
                self.log_text.insert(tk.END, f"Connection from {address}\n")
                
                # Simplified three-way handshake simulation
                syn = client_socket.recv(4)
                self.log_text.insert(tk.END, f"Received SYN: {int.from_bytes(syn, 'big')}\n")
                
                # Send SYN-ACK
                ack_num = int.from_bytes(syn, 'big') + 1
                syn_ack = ack_num.to_bytes(4, 'big') + (12345).to_bytes(4, 'big')
                client_socket.send(syn_ack)
                self.log_text.insert(tk.END, f"Sent SYN-ACK: {int.from_bytes(syn_ack[:4], 'big')}, {int.from_bytes(syn_ack[4:], 'big')}\n")
                
                # Receive ACK
                ack = client_socket.recv(4)
                self.log_text.insert(tk.END, f"Received ACK: {int.from_bytes(ack, 'big')}\n")
                
                client_socket.close()
                
            except:
                break
    
    def connect_client(self):
        try:
            server_ip = self.ip_entry.get()
            server_port = int(self.port_entry.get())
            
            client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            client_socket.connect((server_ip, server_port))
            self.log_text.insert(tk.END, "Connected to server\n")
            
            # Send SYN
            initial_seq = 54321
            client_socket.send(initial_seq.to_bytes(4, 'big'))
            self.log_text.insert(tk.END, f"Sent SYN: {initial_seq}\n")
            
            # Receive SYN-ACK
            syn_ack = client_socket.recv(8)
            server_ack = int.from_bytes(syn_ack[:4], 'big')
            server_seq = int.from_bytes(syn_ack[4:], 'big')
            self.log_text.insert(tk.END, f"Received SYN-ACK: ACK={server_ack}, SEQ={server_seq}\n")
            
            # Send ACK
            final_ack = server_seq + 1
            client_socket.send(final_ack.to_bytes(4, 'big'))
            self.log_text.insert(tk.END, f"Sent ACK: {final_ack}\n")
            self.log_text.insert(tk.END, "Connection established\n")
            
            client_socket.close()
            
        except Exception as e:
            self.log_text.insert(tk.END, f"Connection error: {str(e)}\n")

if __name__ == "__main__":
    root = tk.Tk()
    app = TCPConnectionDemo(root)
    root.mainloop()

Future Aspirations Looking ahead, I aim to continue advancing in full-stack development and deep learning, with particular focus on medical applications. My goals include:

Professional Development Deepening expertise in system architecture, performance optimization, and emerging technologies. I plan to contribute to open-source projects and collaborate with diverse technical communities.

Technical Specialization Further research in medical image analysis and AI-driven healthcare solutions. Exploring new frameworks and tools that enhance development efficiency and application performance.

Knowledge Sharing Expanding content creation to include advanced tutorials, case studies, and practical guides. Developing educational resources that bridge theoretical concepts with real-world applications.