<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Suleiman Hajizadeh on Medium]]></title>
        <description><![CDATA[Stories by Suleiman Hajizadeh on Medium]]></description>
        <link>https://medium.com/@suleyman.hacizade1?source=rss-69b74117fec7------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*TrZWtS3XG2d7uC61zx3s-Q.jpeg</url>
            <title>Stories by Suleiman Hajizadeh on Medium</title>
            <link>https://medium.com/@suleyman.hacizade1?source=rss-69b74117fec7------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 20:44:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@suleyman.hacizade1/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[From Transcriptomics to Protein Structure: Exploring AKT1 in Triple-Negative Breast Cancer Using…]]></title>
            <link>https://medium.com/@suleyman.hacizade1/from-transcriptomics-to-protein-structure-exploring-akt1-in-triple-negative-breast-cancer-using-db6a5a3b17ce?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/db6a5a3b17ce</guid>
            <category><![CDATA[shell]]></category>
            <category><![CDATA[alphafold]]></category>
            <category><![CDATA[jupyter-notebook]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[tex]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Mon, 18 May 2026 20:56:30 GMT</pubDate>
            <atom:updated>2026-06-26T09:48:49.559Z</atom:updated>
            <content:encoded><![CDATA[<h3>From Transcriptomics to Protein Structure: Exploring AKT1 in Triple-Negative Breast Cancer Using AlphaFold2</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JmQWReQpoi96Te3B.png" /></figure><p>Triple-Negative Breast Cancer (TNBC) remains one of the most aggressive and biologically complex subtypes of breast cancer. Unlike other breast cancer types, TNBC lacks expression of estrogen receptor (ER), progesterone receptor (PR), and HER2 amplification, which makes many targeted therapies ineffective. Because of this, researchers increasingly rely on transcriptomics, systems biology, and computational approaches to identify new molecular mechanisms and therapeutic opportunities.</p><p>In my recent bioinformatics project, I wanted to move beyond classical RNA-seq analysis and investigate how transcriptomic findings could be connected to structural biology. Instead of stopping at differential gene expression and hub gene identification, I explored what one of the most important TNBC-associated proteins might actually look like at the structural level.</p><p>This project became a bridge between transcriptomics, protein structure prediction, and structural bioinformatics.</p><p>The complete project, scripts, and visualisations are available on GitHub: https://github.com/SuleimanHajizadeh/computational-structural-biology</p><h3>Why AKT1?</h3><p>Among the differentially expressed hub genes identified during my TNBC transcriptomics analysis, <strong>AKT1</strong> attracted my attention because of its central role in the <strong>PI3K-Akt signalling pathway</strong>, one of the most dysregulated signalling networks in cancer biology.</p><p>AKT1 encodes a serine/threonine kinase responsible for regulating:</p><ul><li>Cell survival</li><li>Cell proliferation</li><li>Glucose metabolism</li><li>Apoptosis suppression</li><li>Growth signalling</li><li>Protein synthesis</li></ul><p>In many cancers, including TNBC, hyperactivation of the PI3K-Akt pathway promotes uncontrolled cellular growth and resistance to apoptosis. Because of this, AKT1 has become a major target in precision oncology and drug development research.</p><p>However, understanding gene expression alone is often insufficient. A gene may be highly expressed, but its biological behaviour depends heavily on the structure and flexibility of the encoded protein.</p><p>This is where structural bioinformatics becomes important.</p><h3>Moving Beyond RNA-seq</h3><p>Most transcriptomics projects typically end after identifying:</p><ul><li>Differentially expressed genes (DEGs)</li><li>Functional enrichment pathways</li><li>Protein-protein interaction networks</li><li>Hub genes</li></ul><p>But I wanted to continue one step further:</p><blockquote><em>What structural properties allow AKT1 to behave as a highly dynamic oncogenic signalling protein?</em></blockquote><p>To investigate this question, I used <strong>AlphaFold2</strong>, one of the most transformative AI systems developed for protein structure prediction.</p><h3>What is AlphaFold2?</h3><p>DeepMind developed <strong>AlphaFold2</strong>, an artificial intelligence system capable of predicting protein 3D structures with unprecedented accuracy.</p><p>Protein structure prediction has historically been one of the biggest challenges in molecular biology because experimental techniques such as:</p><ul><li>X-ray crystallography</li><li>Cryo-electron microscopy (Cryo-EM)</li><li>Nuclear magnetic resonance (NMR)</li></ul><p>are expensive, time-consuming, and technically demanding.</p><p>AlphaFold2 revolutionized the field by using deep learning architectures trained on massive structural datasets to infer atomic-level protein conformations directly from amino acid sequences.</p><p>For this project, I used:</p><ul><li><strong>ColabFold v1.6.1</strong></li><li>MMseqs2-based sequence alignment</li><li>AlphaFold2 prediction pipeline</li></ul><h3>Structural Prediction Workflow</h3><p>The workflow included several major stages:</p><h3>1. Protein Sequence Preparation</h3><p>The amino acid sequence of AKT1 was prepared and submitted into the AlphaFold2 prediction pipeline using ColabFold.</p><h3>2. Structure Prediction</h3><p>AlphaFold2 generated predicted 3D conformations of AKT1 by combining:</p><ul><li>Evolutionary information</li><li>Multiple sequence alignments (MSA)</li><li>Attention-based neural networks</li><li>Spatial geometry optimization</li></ul><p>The final predicted structure included confidence metrics for every residue.</p><h3>3. Confidence Analysis (pLDDT)</h3><p>One of the most important AlphaFold metrics is:</p><h3>Predicted Local Distance Difference Test (pLDDT)</h3><p>0 \leq pLDDT \leq 100</p><p>This score estimates local structural confidence for each amino acid residue.</p><p>General interpretation:</p><ul><li>90–100 → very high confidence</li><li>70–90 → reliable backbone prediction</li><li>50–70 → moderate confidence</li><li>Below 50 → likely flexible or disordered regions</li></ul><p>For AKT1:</p><p>\text{Mean pLDDT} = 65.61</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7AWsF1Ena5Er4X5L.png" /></figure><p>This suggests that the model contains both confidently folded domains and flexible regions.</p><p>Interestingly, this is biologically meaningful rather than problematic.</p><h3>Intrinsically Disordered Regions (IDRs)</h3><p>One of the most interesting findings from the project was:</p><p>\text{IDR Content} = 30.2%</p><p>Intrinsically disordered regions (IDRs) are protein segments that do not adopt stable fixed conformations under physiological conditions.</p><p>Unlike rigid folded domains, IDRs remain flexible and dynamic.</p><p>For many years, these regions were mistakenly considered “unstructured noise.” Modern structural biology now recognizes that IDRs play critical regulatory roles in:</p><ul><li>Signal transduction</li><li>Protein-protein interactions</li><li>Molecular recognition</li><li>Post-translational modification</li><li>Allosteric regulation</li></ul><p>In oncogenic proteins such as AKT1, structural flexibility can become biologically advantageous for cancer cells.</p><p>Flexible regions often act as:</p><ul><li>Interaction hubs</li><li>Regulatory switches</li><li>Dynamic binding surfaces</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*M_c1AEi9F2YIVnj2.png" /></figure><p>This may partially explain why AKT1 participates in numerous signalling pathways simultaneously.</p><h3>Ramachandran and Secondary Structure Analysis</h3><p>To better evaluate the predicted fold quality, I also performed secondary structure and Ramachandran analysis.</p><p>The results showed:</p><ul><li><strong>24.6% α-helices</strong></li><li><strong>32.9% β-strands</strong></li></ul><p>These findings are consistent with the classical bilobal kinase architecture observed in many signalling kinases.</p><p>The Ramachandran plot also supported acceptable stereochemical geometry across most structured regions.</p><p>This suggests that the predicted model is structurally plausible and biologically interpretable.</p><h3>Contact Map Analysis</h3><p>Another interesting part of the project involved contact map analysis.</p><p>A contact map visualizes residue-residue interactions within the protein structure.</p><p>The AKT1 contact map revealed:</p><ul><li>Distinct domain separation</li><li>Long-range residue interactions</li><li>Structural organization patterns</li></ul><p>Importantly, three major domain blocks became visible:</p><ol><li>PH domain</li><li>Kinase domain</li><li>Regulatory domain</li></ol><p>These domains correspond closely with experimentally characterized AKT1 architecture reported in the literature.</p><h3>Connecting Multiple Layers of Biology</h3><p>One of the most rewarding parts of this project was seeing how different biological layers could be integrated into a single workflow:</p><h3>Transcriptomics → Network Biology → Structural Biology</h3><p>The overall pipeline looked like this:</p><ol><li>RNA-seq differential expression analysis using DESeq2</li><li>Hub gene identification through co-expression analysis</li><li>Functional prioritization of AKT1</li><li>Protein structure prediction using AlphaFold2</li><li>Structural interpretation and disorder analysis</li></ol><p>This integration helped transform transcriptomic data from abstract gene lists into biologically interpretable molecular systems.</p><h3>Why Structural Bioinformatics Matters</h3><p>Structural bioinformatics is becoming increasingly important in modern precision medicine because proteins are ultimately the functional molecules responsible for cellular behaviour.</p><p>Genes provide instructions, but proteins execute biological activity.</p><p>Understanding protein structure allows researchers to investigate:</p><ul><li>Drug binding mechanisms</li><li>Mutation effects</li><li>Conformational flexibility</li><li>Active site accessibility</li><li>Allosteric regulation</li><li>Therapeutic targeting opportunities</li></ul><p>As AI-driven structural prediction tools continue to improve, computational biology is increasingly capable of performing analyses that previously required expensive laboratory infrastructure.</p><h3>Open Science and Reproducibility</h3><p>One important goal of this project was maintaining transparency and reproducibility.</p><p>The entire workflow, including:</p><ul><li>Python scripts</li><li>Visualisation notebooks</li><li>Structural analysis outputs</li><li>Prediction files</li></ul><p>has been shared openly on GitHub.</p><p>Open science allows students, researchers, and independent learners to explore, reproduce, and improve computational biology workflows collaboratively.</p><p>GitHub Repository: https://github.com/SuleimanHajizadeh/computational-structural-biology</p><h3>Final Thoughts</h3><p>This project further strengthened my interest in:</p><ul><li>Structural bioinformatics</li><li>Cancer systems biology</li><li>AI-driven molecular biology</li><li>Computational oncology</li></ul><p>It also showed me how modern bioinformatics is no longer limited to sequence analysis alone. Today, we can connect transcriptomics, network biology, machine learning, and structural prediction into unified biological interpretations.</p><p>I am especially inspired by scientists such as Garib Murshudov and Aynura Pashayeva, whose work motivated my growing interest in structural biology and computational research.</p><p>The future of cancer research will increasingly depend on interdisciplinary integration between AI, molecular biology, and bioinformatics — and projects like this demonstrate how accessible these technologies are becoming for independent researchers and students worldwide.</p><p>#Bioinformatics #StructuralBiology #AlphaFold2 #CancerResearch #TNBC #ComputationalBiology #Transcriptomics #AI #OpenScience #GitHub</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db6a5a3b17ce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[System Engineering & DevOps: Building the Foundation Behind Modern Applications]]></title>
            <link>https://medium.com/@suleyman.hacizade1/system-engineering-devops-building-the-foundation-behind-modern-applications-8243f81882d6?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/8243f81882d6</guid>
            <category><![CDATA[shell-script]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ngnix]]></category>
            <category><![CDATA[load-balancing]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 09:53:30 GMT</pubDate>
            <atom:updated>2026-06-26T09:32:20.393Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bpRl1qMX9wnHpDzg.png" /></figure><p>When people think about software development, they often imagine writing code and building applications. But behind every working application, there’s a powerful system infrastructure making everything possible.</p><p>In this article, I’ll share my experience working on a <strong>System Engineering &amp; DevOps project</strong>, where I focused on the core components that keep systems running efficiently and reliably.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*66f7bpqo762raWx_.png" /></figure><h3>Project Overview</h3><p>This project was part of my learning journey in system engineering and DevOps. Instead of focusing only on application development, I worked on:</p><ul><li>Linux system management</li><li>Shell (Bash) scripting</li><li>Networking fundamentals</li><li>Web server configuration</li><li>Automation and process optimization</li></ul><p>The goal was to understand how systems work <em>under the hood</em>.</p><h3>Why System Engineering Matters</h3><p>Modern applications depend heavily on infrastructure. Without proper system design:</p><ul><li>Applications crash</li><li>Performance drops</li><li>Security risks increase</li></ul><p>System engineering ensures that everything runs smoothly, securely, and at scale.</p><h3>Key Areas I Worked On</h3><h3>1. Linux &amp; Shell Scripting</h3><p>Most of the work was done in a Linux environment, where I:</p><ul><li>Navigated the file system</li><li>Managed processes and permissions</li><li>Wrote Bash scripts to automate repetitive tasks</li></ul><p>This improved my efficiency and helped me understand how systems operate at a low level.</p><h3>2. Networking Fundamentals</h3><p>Understanding networking was crucial. I explored:</p><ul><li>IP addressing</li><li>DNS</li><li>HTTP/HTTPS protocols</li><li>Basic troubleshooting</li></ul><p>This helped me see how different parts of a system communicate with each other.</p><h3>3. Web Infrastructure</h3><p>I also worked on setting up and understanding web servers:</p><ul><li>Configuring servers</li><li>Handling requests and responses</li><li>Understanding how websites are served</li></ul><p>This gave me a clearer picture of how applications are delivered to users.</p><h3>4. Security &amp; Access (SSH, Firewall)</h3><p>Security is a critical part of any system. I practiced:</p><ul><li>Using SSH for secure remote access</li><li>Configuring basic firewall rules</li><li>Managing user permissions</li></ul><p>Even small misconfigurations can create vulnerabilities, so attention to detail was key.</p><h3>5. Debugging &amp; Troubleshooting</h3><p>Not everything worked on the first try — and that was the point.</p><p>I learned how to:</p><ul><li>Analyze logs</li><li>Identify system issues</li><li>Fix configuration errors</li></ul><p>This made me more confident in handling real-world problems.</p><h3>What I Learned</h3><p>This project taught me that:</p><ul><li>DevOps is not just tools — it’s a mindset</li><li>Automation saves time and reduces errors</li><li>Understanding systems makes you a better developer</li><li>Troubleshooting is a critical skill</li></ul><h3>Real-World Relevance</h3><p>In real-world environments:</p><ul><li>Systems must be scalable</li><li>Downtime must be minimized</li><li>Security must be enforced</li></ul><p>The concepts I worked on in this project directly apply to real production systems.</p><h3>Final Thoughts</h3><p>This experience helped me move beyond just writing code and start thinking like a system engineer.</p><p>If you want to grow as a developer, don’t ignore what happens behind the scenes. Learn how systems work, how they break, and how to fix them.</p><p>That’s where real growth happens.</p><p>GitHub: https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8243f81882d6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fix My Code Challenge: What Debugging Taught Me About Real Programming]]></title>
            <link>https://medium.com/@suleyman.hacizade1/fix-my-code-challenge-what-debugging-taught-me-about-real-programming-d8dc487e23e4?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8dc487e23e4</guid>
            <category><![CDATA[problem-solving]]></category>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[error-handling]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 09:40:21 GMT</pubDate>
            <atom:updated>2026-06-26T09:40:37.005Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ktOkIvKhUF7JyMDI.png" /></figure><p>Debugging is one of the most underrated yet essential skills in software development. While building projects from scratch is important, working with <em>broken code</em> teaches you how to think like a true engineer.</p><p>In this article, I’ll share my experience working on the <strong>Fix My Code Challenge</strong>, a hands-on project where I had to <strong>analyze</strong>, <strong>debug</strong>, and <strong>fix</strong> <strong>code</strong> written in <strong>multiple</strong> <strong>programming</strong> <strong>languages</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*B5ZcigPCzTNYX1Ol" /></figure><h3>Project Overview</h3><p>The <strong>Fix My Code Challenge</strong> is focused on improving debugging skills by working with existing, non-functional codebases. Instead of writing code from scratch, the goal is to:</p><ul><li>Understand what the code is supposed to do</li><li>Identify bugs and logical errors</li><li>Fix issues without rewriting the entire implementation</li></ul><p>This project included working with multiple languages such as:</p><ul><li>Python</li><li>JavaScript</li><li>Ruby</li><li>C</li></ul><h3>Why Debugging Matters</h3><p>Many beginner developers focus heavily on writing code but underestimate debugging. In reality:</p><blockquote><em>Writing code is only half the job — fixing it is where real understanding begins.</em></blockquote><p>Debugging helps you:</p><ul><li>Think critically</li><li>Understand system behavior</li><li>Read and interpret unfamiliar code</li><li>Improve problem-solving skills</li></ul><h3>Challenges I Faced</h3><h3>1. Understanding чужой (someone else’s) code</h3><p>One of the hardest parts was working with code written by someone else. There were cases where:</p><ul><li>Variable names were unclear</li><li>Logic was not documented</li><li>Code structure was confusing</li></ul><p>This forced me to carefully trace execution step by step.</p><h3>2. Multi-language Debugging</h3><p>Each programming language has its own:</p><ul><li>Syntax</li><li>Error messages</li><li>Debugging tools</li></ul><p>For example:</p><ul><li>In <strong>Python</strong>, errors were often straightforward but required logical fixes</li><li>In <strong>C</strong>, small mistakes could cause crashes or undefined behavior</li><li>In <strong>JavaScript</strong>, asynchronous behavior added complexity</li></ul><h3>3. Fixing Without Rewriting</h3><p>A key rule of the challenge was:</p><blockquote><em>❗ Do NOT rewrite the code — fix it.</em></blockquote><p>This taught me how to:</p><ul><li>Respect existing architecture</li><li>Make minimal, precise changes</li><li>Avoid introducing new bugs</li></ul><h3>My Debugging Approach</h3><p>Through this project, I developed a structured debugging strategy:</p><h3>Step 1: Reproduce the error</h3><p>Run the program and observe what goes wrong.</p><h3>Step 2: Read the code carefully</h3><p>Understand the logic before touching anything.</p><h3>Step 3: Isolate the problem</h3><p>Find the exact line or function causing the issue.</p><h3>Step 4: Test small fixes</h3><p>Make minimal changes and test frequently.</p><h3>Step 5: Verify the solution</h3><p>Ensure the fix works and doesn’t break other parts.</p><h3>Key Lessons Learned</h3><ul><li>Debugging is a core engineering skill</li><li>Reading code is just as important as writing it</li><li>Small fixes can have a big impact</li><li>Patience and persistence are critical</li></ul><h3>Real-World Impact</h3><p>In real-world software development:</p><ul><li>You will often work with legacy code</li><li>You will fix bugs more than you write new features</li><li>You will collaborate with code written by others</li></ul><p>This project simulated exactly that environment.</p><h3>Final Thoughts</h3><p>The <strong>Fix My Code Challenge</strong> changed how I approach programming. It shifted my mindset from just building things to truly <em>understanding</em> them.</p><p>If you want to become a better developer, don’t just write code — break it, analyze it, and fix it.</p><p>GitHub: https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8dc487e23e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Networking Fundamentals: A Practical Learning Journey]]></title>
            <link>https://medium.com/@suleyman.hacizade1/understanding-networking-fundamentals-a-practical-learning-journey-f98ef21f197d?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/f98ef21f197d</guid>
            <category><![CDATA[tcp-ip]]></category>
            <category><![CDATA[computer-networking]]></category>
            <category><![CDATA[osi-model]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Mon, 09 Mar 2026 06:30:51 GMT</pubDate>
            <atom:updated>2026-06-26T09:41:20.197Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/490/0*FOkKgI2r-fsKNQMd" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DNkRugxCbIhj1Wzb.jpg" /></figure><p>Modern software systems rely heavily on networking. Every web request, API call, or cloud deployment depends on reliable communication between machines. As part of my learning journey in software engineering, I worked on a networking project that explores the fundamental concepts behind how computers communicate across networks.</p><p>This article summarizes the key topics I studied and implemented while working on the repository below.</p><h3>Why Networking Knowledge Matters for Developers</h3><p>Many developers focus mainly on writing code but often overlook the underlying infrastructure that allows applications to communicate. However, understanding networking concepts is extremely important for:</p><ul><li>Backend developers</li><li>DevOps engineers</li><li>Cloud engineers</li><li>Cybersecurity specialists</li><li>System administrators</li></ul><p>Without networking knowledge it becomes difficult to understand issues like:</p><ul><li>Why a server cannot be reached</li><li>Why an API request fails</li><li>Why DNS resolution does not work</li><li>Why latency occurs in distributed systems</li></ul><p>Learning networking fundamentals helps developers debug systems more effectively and build scalable architectures.</p><h3>The OSI Model: Understanding Network Layers</h3><p>One of the most important concepts in networking is the <strong>OSI (Open Systems Interconnection) model</strong>, which describes how network communication is structured.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yrSSnUzep9M6R2CU" /></figure><p>The OSI model consists of <strong>seven layers</strong>:</p><ol><li>Physical Layer<br>Handles the physical transmission of data through cables, signals, and hardware.</li><li>Data Link Layer<br>Responsible for communication between devices within the same network segment.</li><li>Network Layer<br>Manages routing and addressing of packets between different networks.</li><li>Transport Layer<br>Ensures reliable communication between hosts. Common protocols include TCP and UDP.</li><li>Session Layer<br>Manages sessions and connections between applications.</li><li>Presentation Layer<br>Handles data formatting, encryption, and compression.</li><li>Application Layer<br>The interface where applications interact with the network (HTTP, FTP, SMTP, DNS).</li></ol><p>Understanding these layers helps developers identify where networking problems occur.</p><h3>TCP vs UDP: Two Core Transport Protocols</h3><p>The Transport Layer commonly uses two protocols: <strong>TCP</strong> and <strong>UDP</strong>.</p><p>TCP (Transmission Control Protocol)</p><p>TCP is connection-oriented and provides reliable communication. It ensures that:</p><ul><li>Data arrives in the correct order</li><li>Lost packets are retransmitted</li><li>Communication errors are minimized</li></ul><p>Examples of TCP usage:</p><ul><li>HTTP / HTTPS</li><li>Email services</li><li>File transfers</li></ul><p>UDP (User Datagram Protocol)</p><p>UDP is connectionless and faster but less reliable. It does not guarantee delivery or order.</p><p>Examples of UDP usage:</p><ul><li>Video streaming</li><li>Online gaming</li><li>DNS queries</li><li>VoIP</li></ul><p>This project helped reinforce when each protocol is appropriate depending on the system requirements.</p><h3>IP Addressing and Subnetting</h3><p>Every device connected to a network requires an <strong>IP address</strong>. An IP address identifies a device so that packets can be delivered correctly.</p><p>There are two major IP versions:</p><p>IPv4<br>Example: 192.168.1.1</p><p>IPv6<br>Example: 2001:0db8:85a3:0000:0000:8a2e:0370:7334</p><p>IPv4 addresses are limited and therefore networks use <strong>subnetting</strong> to efficiently allocate addresses.</p><p>Subnetting divides networks into smaller segments to improve:</p><ul><li>security</li><li>performance</li><li>network organization</li></ul><p>Understanding subnet masks and CIDR notation is essential when designing or troubleshooting networks.</p><h3>DNS: The Internet’s Phonebook</h3><p>Humans prefer domain names, but computers communicate using IP addresses. DNS (Domain Name System) translates domain names into IP addresses.</p><p>Example:</p><p>google.com → 142.250.x.x</p><p>The DNS resolution process typically includes:</p><ol><li>Client request</li><li>Recursive resolver</li><li>Root DNS server</li><li>TLD server (.com, .org, etc.)</li><li>Authoritative DNS server</li></ol><p>This layered lookup process allows the internet to scale globally.</p><h3>HTTP and HTTPS Communication</h3><p>Most modern web applications communicate using HTTP or HTTPS.</p><p>HTTP (Hypertext Transfer Protocol)</p><p>HTTP defines how web browsers and servers exchange information. A typical request includes:</p><ul><li>method (GET, POST, PUT, DELETE)</li><li>headers</li><li>body</li></ul><p>HTTPS</p><p>HTTPS is simply HTTP with encryption using TLS/SSL. It protects:</p><ul><li>user data</li><li>authentication credentials</li><li>sensitive information</li></ul><p>Today almost all production systems rely on HTTPS for secure communication.</p><h3>Linux Networking Tools</h3><p>Practical networking knowledge often comes from using command-line tools. During this project, several Linux utilities were used to inspect and troubleshoot network connections.</p><p>Some important tools include:</p><p>ping<br>Tests connectivity between hosts.</p><p>curl<br>Makes HTTP requests directly from the terminal.</p><p>netstat / ss<br>Displays network connections and open ports.</p><p>dig<br>Performs DNS lookups.</p><p>These tools help developers understand what happens behind the scenes during network communication.</p><h3>Key Lessons from This Project</h3><p>Working on this networking project reinforced several important concepts:</p><p>Understanding network layers simplifies debugging.</p><p>Protocols like TCP and UDP serve different purposes depending on reliability and speed requirements.</p><p>DNS plays a critical role in translating human-readable domain names into machine-readable IP addresses.</p><p>Networking tools in Linux provide powerful insights into system behavior.</p><p>For developers working with cloud infrastructure, APIs, and distributed systems, networking knowledge is essential.</p><h3>Conclusion</h3><p>Networking forms the backbone of modern computing. Whether building web applications, deploying microservices, or managing cloud infrastructure, understanding how data travels across networks is crucial.</p><p>This project helped me build a stronger foundation in networking concepts and practical troubleshooting techniques.</p><p>GitHub: https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations</p><p>I plan to continue exploring deeper networking topics such as:</p><ul><li>Load balancing</li><li>Reverse proxies</li><li>Container networking</li><li>Cloud networking architectures</li></ul><p>If you’re learning software engineering or DevOps, I highly recommend investing time in networking fundamentals.</p><p>Thanks for reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f98ef21f197d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning React Through Practice: My Holberton Web React Project]]></title>
            <link>https://medium.com/@suleyman.hacizade1/learning-react-through-practice-my-holberton-web-react-project-0894cfa58cf5?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/0894cfa58cf5</guid>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-typescript]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[typescript-with-react]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Mon, 09 Mar 2026 06:13:28 GMT</pubDate>
            <atom:updated>2026-06-26T09:42:04.645Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-CTTZlWePYTJm67u" /></figure><h3>Introduction</h3><p>Modern web development has rapidly evolved over the past decade, and <strong>React</strong> has become one of the most widely used libraries for building interactive user interfaces. React allows developers to create reusable components, manage application state efficiently, and build scalable web applications.</p><p>As part of my journey in learning front-end development, I worked on a repository called <strong>holbertonschool-web_react</strong>, where I practiced fundamental and intermediate React concepts.</p><p>This project contains multiple exercises and tasks designed to help understand how React applications are structured and how modern JavaScript frameworks operate in real-world projects.</p><h3>Project Overview</h3><p>The repository <strong>holbertonschool-web_react</strong> is a collection of React exercises and mini-projects that focus on:</p><ul><li>React fundamentals</li><li>Component architecture</li><li>State management</li><li>Modern JavaScript (ES6+)</li><li>Webpack and build configuration</li><li>Frontend project structure</li></ul><p>The goal of this project is to <strong>develop practical React skills</strong> by implementing features step by step and understanding how React applications are built internally.</p><h3>What is React?</h3><p>React is a <strong>JavaScript library used for building user interfaces</strong>, particularly single-page applications (SPAs). It allows developers to build complex interfaces by breaking them down into smaller reusable components.</p><p>Key benefits of React include:</p><ul><li>Component-based architecture</li><li>Virtual DOM for performance</li><li>Reusable UI components</li><li>Strong ecosystem and community</li></ul><p>React applications are typically built using <strong>JavaScript, JSX, HTML, and CSS</strong>.</p><h3>Technologies Used</h3><p>This project uses several modern web development tools and technologies.</p><h3>JavaScript (ES6+)</h3><p>Modern JavaScript syntax such as:</p><ul><li>arrow functions</li><li>modules</li><li>destructuring</li><li>classes</li></ul><h3>React</h3><p>Used to create reusable UI components and manage the application interface.</p><h3>JSX</h3><p>JSX is a syntax extension for JavaScript that allows developers to write HTML-like code inside JavaScript files.</p><p>Example:</p><pre>const element = &lt;h1&gt;Hello, world!&lt;/h1&gt;;</pre><p>JSX makes UI development easier and more readable.</p><h3>Repository Structure</h3><p>A typical React project follows a structured organization. In this repository, folders are organized to separate components, configuration files, and application logic.</p><p>Example structure:</p><pre>holbertonschool-web_react/<br>│<br>├── 0x00-Webpack<br>├── 0x01-react_intro<br>├── 0x02-react_props<br>├── 0x03-react_state<br>├── 0x04-react_redux<br>└── README.md</pre><p>Each folder represents a <strong>specific learning module or concept in React development</strong>.</p><h3>Key Concepts Practiced in This Project</h3><h3>Webpack Configuration</h3><p>Webpack is a module bundler used to bundle JavaScript files and assets for the browser.</p><p>It helps developers:t</p><ul><li>bundle code</li><li>optimize assets</li><li>manage dependencies</li></ul><p>Example configuration snippet:</p><pre>module.exports = {<br>  entry: &quot;./src/index.js&quot;,<br>  output: {<br>    filename: &quot;bundle.js&quot;<br>  }<br>};</pre><p>Webpack improves application performance and organizes project assets efficiently.</p><h3>React Components</h3><p>React applications are built using <strong>components</strong>.</p><p>A component is a reusable piece of UI that can contain logic, layout, and styling.</p><p>Example component:</p><pre>function Welcome(props) {<br>  return &lt;h1&gt;Hello, {props.name}&lt;/h1&gt;;<br>}</pre><p>Components help make code modular and maintainable.</p><h3>Props in React</h3><p>Props (properties) allow data to be passed from one component to another.</p><p>Example:</p><pre>function User(props) {<br>  return &lt;h2&gt;{props.name}&lt;/h2&gt;;<br>}</pre><p>Props are <strong>read-only</strong> and help maintain predictable data flow.</p><h3>State Management</h3><p>State allows components to store and update dynamic data.</p><p>Example using React state:</p><pre>const [count, setCount] = useState(0);</pre><p>State is essential for interactive applications like:</p><ul><li>counters</li><li>forms</li><li>dashboards</li><li>dynamic UI elements</li></ul><h3>Redux (Advanced State Management)</h3><p>In larger applications, managing state across multiple components becomes complex.</p><p>Redux helps solve this by creating a <strong>centralized state store</strong> for the entire application.</p><p>Redux concepts include:</p><ul><li>actions</li><li>reducers</li><li>store</li><li>dispatch</li></ul><p>This pattern helps maintain predictable state updates.</p><h3>What I Learned From This Project</h3><p>Working on this repository helped me understand several important concepts:</p><ul><li>Structuring React applications</li><li>Writing reusable components</li><li>Managing state effectively</li><li>Understanding build tools like Webpack</li><li>Improving JavaScript ES6 skills</li></ul><p>These concepts are essential for becoming a professional <strong>Front-End Developer</strong>.</p><h3>Project Repository</h3><p>You can explore the full project here:</p><p>GitHub: https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations</p><p>Feel free to clone the repository, explore the code, and experiment with the exercises.</p><h3>Conclusion</h3><p>Learning React requires both theoretical understanding and practical experience. This project helped reinforce my understanding of modern front-end development tools and workflows.</p><p>By building small exercises and experimenting with components, state, and configuration tools, I gained valuable insights into how modern web applications are developed.</p><p>This is only the beginning of my journey into <strong>React and modern web development</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0894cfa58cf5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Containerizing a Full-Stack Application with Docker, Nginx and Load Balancing]]></title>
            <link>https://medium.com/@suleyman.hacizade1/containerizing-a-full-stack-application-with-docker-nginx-and-load-balancing-49b9a6ba139f?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/49b9a6ba139f</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[docker-compose]]></category>
            <category><![CDATA[api-python]]></category>
            <category><![CDATA[nginx]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Thu, 05 Mar 2026 05:58:15 GMT</pubDate>
            <atom:updated>2026-06-26T09:42:54.085Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/581/0*jafs0kTy8cvdubWy.png" /></figure><p>Modern software development increasingly relies on <strong>containers</strong> to build, ship, and run applications consistently across different environments. Instead of manually configuring dependencies and runtime environments on every machine, developers package applications into containers that include everything required to run the software.</p><p>In this article, I’ll walk through how I built and deployed a containerized web application using Docker, Docker Compose, and an Nginx reverse proxy. The project demonstrates how to separate services into containers, connect them through a network, and scale the backend using load balancing.</p><p>This project was developed as part of a practical software engineering curriculum focused on <strong>real-world infrastructure and DevOps practices</strong>. Programs like those at <strong>Holberton School</strong> emphasize hands-on learning through real projects rather than purely theoretical study.</p><h3>Why Containerization Matters</h3><p>Traditional deployments often suffer from the classic problem:</p><blockquote><em>“It works on my machine.”</em></blockquote><p>Different operating systems, library versions, and configurations can break applications when moving from development to production.</p><p>Containers solve this problem by packaging applications and their dependencies together. Docker containers ensure that the same environment runs everywhere, making applications <strong>portable, reproducible, and scalable</strong>.</p><p>Containerization also makes it easier to:</p><ul><li>isolate services</li><li>scale application components</li><li>simplify deployments</li><li>improve reliability</li></ul><h3>Project Architecture</h3><p>The application is divided into three main components:</p><pre>Client (Browser)<br>        │<br>        ▼<br>   Nginx Proxy<br>      /   \<br>     ▼     ▼<br>Front-end   Back-end API<br>               │<br>               ▼<br>         Application Logic</pre><p>Each component runs inside its own container.</p><h3>Components</h3><p><strong>Front-end</strong></p><ul><li>Serves the user interface</li><li>Built as a static web application</li></ul><p><strong>Back-end</strong></p><ul><li>Python API server</li><li>Handles application logic and API endpoints</li></ul><p><strong>Reverse Proxy</strong></p><ul><li>Nginx server</li><li>Routes requests between the front-end and the API</li></ul><p>This architecture separates concerns and mirrors how modern microservice-based systems are deployed.</p><h3>Repository Structure</h3><p>The project repository is organized into multiple tasks that gradually build the final architecture.</p><p>Example structure:</p><pre>holbertonschool-softy-pinko-docker<br>│<br>├── task0<br>├── task1<br>├── task2<br>├── task3<br>├── task4<br>├── task5<br>└── task6<br>    ├── back-end<br>    ├── front-end<br>    ├── proxy<br>    └── docker-compose.yml</pre><p>Each task introduces a new concept such as containerization, service networking, reverse proxies, or scaling.</p><h3>Step 1: Containerizing the Backend</h3><p>The backend is a Python API service.</p><p>The Dockerfile builds an image for the API:</p><pre>FROM python:3.10</pre><pre>WORKDIR /app</pre><pre>COPY . .</pre><pre>RUN pip install flask</pre><pre>CMD [&quot;python3&quot;, &quot;api.py&quot;]</pre><p>This Dockerfile does several things:</p><ul><li>uses a Python base image</li><li>copies application files into the container</li><li>installs dependencies</li><li>runs the API server</li></ul><p>After building the image:</p><pre>docker build -t softy-pinko-back-end .</pre><p>The backend container now runs independently of the host system.</p><h3>Step 2: Containerizing the Frontend</h3><p>The front-end is served through a web server container.</p><p>Example Dockerfile:</p><pre>FROM nginx:latest</pre><pre>COPY ./softy-pinko-front-end /usr/share/nginx/html</pre><p>This container simply hosts the static website using Nginx.</p><p>When the container runs, users can access the UI from the browser.</p><h3>Step 3: Using Docker Compose</h3><p>Managing multiple containers manually quickly becomes complex.</p><p>Docker Compose solves this by defining services in a single configuration file.</p><p>Example:</p><pre>services:<br>  back-end:<br>    build: ./back-end<br>    image: softy-pinko-back-end:task5<br>front-end:<br>    build: ./front-end<br>    image: softy-pinko-front-end:task5<br>  proxy:<br>    build: ./proxy<br>    image: softy-pinko-proxy:task5<br>    ports:<br>      - &quot;80:80&quot;<br>    depends_on:<br>      - back-end<br>      - front-end</pre><p>With Compose, the entire stack can be started using one command:</p><pre>docker compose up</pre><p>This creates a network where containers can communicate using their service names.</p><p>For example:</p><pre>http://back-end:5252</pre><h3>Step 4: Configuring the Nginx Reverse Proxy</h3><p>The reverse proxy sits between users and application services.</p><p>Example Nginx configuration:</p><pre>server {<br>    listen 80;<br>    location / {<br>        proxy_pass http://front-end:9000;<br>    }<br>    location /api {<br>        proxy_pass http://back-end:5252;<br>    }<br>}</pre><p>This configuration means:</p><ul><li>requests to / go to the frontend</li><li>requests to /api go to the backend</li></ul><p>The proxy acts as a gateway for the entire application.</p><h3>Step 5: Scaling the Backend</h3><p>One of the most powerful advantages of containers is <strong>horizontal scaling</strong>.</p><p>Instead of running a single backend server, we can run multiple instances.</p><p>Using Docker Compose:</p><pre>docker compose up --scale back-end=2</pre><p>This launches two backend containers.</p><p>Example:</p><pre>task6-back-end-1<br>task6-back-end-2</pre><p>The Nginx proxy distributes requests across both servers.</p><p>This technique improves:</p><ul><li>availability</li><li>performance</li><li>reliability</li></ul><p>If one container fails, others can still serve requests.</p><h3>Step 6: Testing the System</h3><p>After deployment, we can verify the system by accessing the application through the browser.</p><p>Example:</p><pre>http://SERVER_IP</pre><p>Requests flow through the following path:</p><pre>Browser<br>   │<br>   ▼<br>Nginx Proxy<br>   │<br>   ├── Frontend container<br>   └── Backend containers</pre><p>By monitoring logs, we can observe requests being served by different backend instances.</p><h3>Challenges During Development</h3><p>While implementing this architecture, several common issues appeared:</p><h3>404 errors</h3><p>Often caused by incorrect proxy routes or missing assets.</p><h3>container networking issues</h3><p>Sometimes containers could not reach each other due to incorrect service names.</p><h3>rebuild vs restart confusion</h3><p>Changes to Dockerfiles or Nginx configs required rebuilding containers.</p><p>Commands used frequently:</p><pre>docker compose build<br>docker compose up -d<br>docker compose restart<br>docker ps<br>docker logs</pre><p>These tools are essential for debugging containerized environments.</p><h3>What I Learned From This Project</h3><p>This project helped me understand several important DevOps concepts:</p><h3>containerization</h3><p>Packaging applications and dependencies into portable containers.</p><h3>service architecture</h3><p>Separating application layers into independent services.</p><h3>reverse proxy design</h3><p>Routing requests efficiently between services.</p><h3>container networking</h3><p>Allowing services to communicate through Docker networks.</p><h3>horizontal scaling</h3><p>Running multiple instances of a service for better reliability.</p><p>These are fundamental skills used in modern cloud environments.</p><h3>Future Improvements</h3><p>This project could be extended with more production-ready features:</p><ul><li>Kubernetes orchestration</li><li>CI/CD pipelines</li><li>monitoring with Prometheus and Grafana and Zabbix</li><li>automated deployments</li><li>HTTPS with Let’s Encrypt</li></ul><p>Container orchestration platforms like Kubernetes build upon Docker to manage large-scale distributed systems.</p><h3>Conclusion</h3><p>Containerization has transformed how applications are developed and deployed. By packaging services into containers, developers gain consistency, scalability, and portability across environments.</p><p>Through this project, I implemented a full workflow that includes:</p><ul><li>containerizing applications</li><li>managing multi-service architecture</li><li>configuring reverse proxies</li><li>scaling backend services</li></ul><p>These are essential DevOps and backend engineering skills that are widely used in modern software infrastructure.</p><p>Project repository:<br>GitHub: https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49b9a6ba139f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Reproducible RNA-Seq Pipeline: From Raw Data to Biological Insights]]></title>
            <link>https://medium.com/@suleyman.hacizade1/building-a-reproducible-rna-seq-pipeline-from-raw-data-to-biological-insights-1d9651bba9bc?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d9651bba9bc</guid>
            <category><![CDATA[scp]]></category>
            <category><![CDATA[bash-script]]></category>
            <category><![CDATA[r-programming]]></category>
            <category><![CDATA[htop]]></category>
            <category><![CDATA[fastqc]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Sun, 11 Jan 2026 09:13:19 GMT</pubDate>
            <atom:updated>2026-06-26T10:31:19.868Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/346/0*bVveAdRYT0xrboMP" /><figcaption>Bash Scripting-To automate tasks so I didn’t have to type commands thousands of times</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*14TorrgU36ckM2ci.png" /><figcaption>Before analyzing anything, we must ensure the data is clean. Sequencing errors, adapter contamination, or low-quality reads can bias the results</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*Qer_4ZNcSMA_AsHuhikGSg.png" /><figcaption>STAR (Spliced Transcripts Alignment to a Reference)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*r_DfrDDrajPoh5bn.png" /><figcaption>featureCounts (Subread package)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8XL4CUkvwFaciZ7q.png" /><figcaption>Running multiple tools on multiple samples generates dozens of log files. Checking them individually is inefficient</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/0*99Ao-k0NLmxeUqUV.png" /><figcaption>statistical visualization to understand the biological story</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*keJe7CQ5bhmUgHLIZbN6NA.png" /><figcaption>RNA-Seq results</figcaption></figure><h3>Title</h3><h3>Building a Reproducible RNA-Seq Pipeline: From Raw Data to Biological Insights</h3><h3>Subtitle</h3><p><em>A comprehensive guide to analyzing transcriptomic data using FastQC, STAR, featureCounts, and R — complete with open-source code.</em></p><p>In the era of “Big Data” biology, the ability to sequence a genome is only half the battle. The real challenge — and the real science — lies in making sense of the millions of reads generated by sequencing machines.</p><p>Recently, I embarked on a project to build a complete <strong>RNA-Seq analysis pipeline</strong>. My goal was not just to run tools blindly, but to understand the logic behind each step: from assessing raw data quality to visualizing gene expression levels.</p><p>I have documented the entire workflow, including automation scripts and analysis code, in my GitHub repository. You can follow along with the code here:</p><p><a href="https://github.com/SuleimanHajizadeh/Bioinformatics-analysis"><strong>GitHub Repository: Bioinformatics-analysis</strong></a></p><p>Here is a deep dive into how I built this pipeline, the tools I used, and the biological “why” behind every command.</p><h3>1. The Environment &amp; The Setup</h3><p>Bioinformatics requires a robust environment. You cannot simply double-click these files. I set up a Unix-based environment (Linux/Bash) to handle the heavy lifting.</p><p>Key system tools I relied on:</p><ul><li><strong>Bash Scripting:</strong> To automate tasks so I didn’t have to type commands thousands of times.</li><li><strong>htop:</strong> A vital tool for monitoring server resources (CPU/RAM) in real-time. RNA-Seq alignment can be heavy, and keeping an eye on the “pulse” of the server is crucial.</li><li><strong>scp:</strong> For securely transferring large datasets and results between the remote server and my local machine.</li></ul><h3>2. The “Golden Chain” of Analysis</h3><p>My pipeline follows the standard industry workflow for Transcriptomics. Here is the step-by-step breakdown:</p><h3>Step 1: Quality Control (QC) — The Gatekeeper</h3><ul><li><strong>Tool used:</strong> FastQC</li><li><strong>The Logic:</strong> Before analyzing anything, we must ensure the data is clean. Sequencing errors, adapter contamination, or low-quality reads can bias the results.</li><li><strong>Process:</strong> I ran FastQC on the raw .fastq files. It checks the Phred scores (quality scores) of the DNA bases. Think of this as checking fruit at the market—discarding the bad ones so they don&#39;t spoil the whole batch.</li></ul><h3>Step 2: Alignment — Solving the Puzzle</h3><ul><li><strong>Tool used:</strong> STAR (Spliced Transcripts Alignment to a Reference)</li><li><strong>The Logic:</strong> We have millions of short fragments (reads), and we need to find where they belong on the human genome.</li><li><strong>Why STAR?</strong> Unlike DNA mapping, RNA mapping is tricky because of <strong>splicing</strong> (introns are removed). STAR is “splice-aware” — it knows how to handle gaps in the alignment, mapping reads correctly across exons.</li></ul><blockquote>You can find the exact STAR parameters and shell scripts I used in the of my <a href="https://github.com/SuleimanHajizadeh/Bioinformatics-analysis">GitHub repo</a>.</blockquote><h3>Step 3: Quantification — The Voting System</h3><ul><li><strong>Tool used:</strong> featureCounts (Subread package)</li><li><strong>The Logic:</strong> Once the reads are mapped, we need to count them. How many reads landed on Gene A vs. Gene B?</li><li><strong>Process:</strong> featureCounts overlaps the aligned reads (BAM files) with the gene annotation file (GTF). The result is a <strong>Count Matrix</strong> — a table of numbers representing the expression level of every gene.</li></ul><h3>Step 4: Aggregation — The Dashboard</h3><ul><li><strong>Tool used:</strong> MultiQC</li><li><strong>The Logic:</strong> Running multiple tools on multiple samples generates dozens of log files. Checking them individually is inefficient.</li><li><strong>Process:</strong> MultiQC scans the entire project directory and aggregates reports from FastQC, STAR, and featureCounts into a single, interactive HTML dashboard. This allows for immediate detection of batch effects or failed samples.</li></ul><h3>3. Visualization: Bringing Data to Life with R</h3><p>The final and most rewarding step involves moving from the command line to <strong>R</strong>.</p><p>Using the count matrix generated in the previous step, I performed statistical visualization to understand the biological story.</p><ul><li><strong>Data Cleaning:</strong> Importing the matrix and filtering out low-expression genes.</li><li><strong>Visualization:</strong> Creating bar plots to showcase the most highly expressed genes in the dataset.</li></ul><pre># Example snippet from my analysis (full code in repo)<br>barplot(gene_counts, <br>        main = &quot;Gene Expression Levels&quot;, <br>        xlab = &quot;Genes&quot;, <br>        ylab = &quot;Counts&quot;, <br>        col = &quot;steelblue&quot;)</pre><p>This visual output transforms abstract numbers into actionable biological insights.</p><h3>4. Why Automation Matters</h3><p>One of the key takeaways from this project was the importance of <strong>reproducibility</strong>. By wrapping these steps into Bash scripts (available in the repository), the entire analysis can be repeated by anyone, on any compatible dataset, with a single command.</p><h3>Conclusion &amp; Future Steps</h3><p>Building this pipeline has bridged the gap for me between computer science and biology. I now have a functional workflow that takes raw sequencing data and outputs clean, analyzable expression matrices.</p><p>My next steps involve expanding this pipeline to include <strong>Differential Expression Analysis (DESeq2)</strong> to compare healthy vs. diseased tissues.</p><p>Feel free to explore the code, fork the repository, and connect with me if you are on a similar journey!</p><p>GitHub: <a href="https://github.com/SuleimanHajizadeh/Bioinformatics-analysis">https://github.com/SuleimanHajizadeh/Bioinformatics-analysis</a></p><p>#Bioinformatics #RNASeq #DataScience #Genomics #GitHub #OpenSource #Research</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d9651bba9bc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python3: Mutable, Immutable — Everything Is An Object]]></title>
            <link>https://medium.com/@suleyman.hacizade1/python3-mutable-immutable-everything-is-an-object-be6a120b5393?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/be6a120b5393</guid>
            <category><![CDATA[python3]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[python-web-developer]]></category>
            <category><![CDATA[python-libraries]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Thu, 18 Dec 2025 18:34:25 GMT</pubDate>
            <atom:updated>2026-06-26T10:34:37.312Z</atom:updated>
            <content:encoded><![CDATA[<h3>Python3: Mutable, Immutable — Everything Is An Object</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/409/0*OJPSCW9U5Lv3GfVr.png" /></figure><h3>Introduction</h3><p>Python often feels simple on the surface, but under that simplicity lies a very consistent object model: <strong>everything is an object</strong>. In this project, I revisited Python fundamentals — id, type, mutability, immutability, and function argument passing—and realized how many real‑world bugs and surprises come from not fully understanding these concepts. This post summarizes what I learned, with concrete examples you can run yourself.</p><h3>id() and type()</h3><p>Every object in Python has:</p><p>An <strong>identity</strong> (its memory address during its lifetime), accessible via id()</p><p>A <strong>type</strong>, accessible via type()</p><pre>x = 42<br>y = 42</pre><pre>print(id(x))<br>print(id(y))<br>print(type(x))</pre><p>Output (example):</p><pre>140712345678416<br>140712345678416<br>&lt;class &#39;int&#39;&gt;</pre><p>Here, x and y refer to the <strong>same object</strong> because small integers are cached by CPython. Identity equality (id(x) == id(y)) is different from value equality (x == y), but sometimes they coincide.</p><p>Another example with lists:</p><pre>a = [1, 2, 3]<br>b = [1, 2, 3]</pre><pre>print(a == b)   # value equality<br>print(a is b)   # identity equality</pre><pre>True<br>False</pre><p>Same value, different objects.</p><h3>Mutable Objects</h3><p>A <strong>mutable object</strong> can be changed after it is created, without changing its identity.</p><p>Common mutable types:</p><ul><li>list</li><li>dict</li><li>set</li><li>most custom objects</li></ul><p>Example:</p><pre>lst = [1, 2, 3]<br>print(id(lst))</pre><pre>lst.append(4)<br>print(lst)<br>print(id(lst))</pre><pre>[1, 2, 3, 4]<br># id stays the same</pre><p>The list changes <strong>in place</strong>. The object identity does not change, only its internal state.</p><p>Another important example:</p><pre>a = [1, 2]<br>b = a</pre><pre>b.append(3)<br>print(a)</pre><pre>[1, 2, 3]</pre><p>Both a and b reference the same mutable object.</p><h3>Immutable Objects</h3><p>An <strong>immutable object</strong> cannot be changed after it is created. Any “change” creates a <strong>new object</strong>.</p><p>Common immutable types:</p><ul><li>int</li><li>float</li><li>bool</li><li>str</li><li>tuple</li><li>frozenset</li></ul><p>Example with integers:</p><pre>x = 10<br>print(id(x))</pre><pre>x += 1<br>print(x)<br>print(id(x))</pre><pre>11<br># id is different</pre><p>The value 10 was never modified. A <strong>new integer object</strong> was created.</p><p>Example with strings:</p><pre>s = &quot;hello&quot;<br>print(id(s))</pre><pre>s += &quot; world&quot;<br>print(s)<br>print(id(s))</pre><p>Again, a new object is created.</p><p>Even tuples (which may contain mutable objects):</p><pre>t = (1, [2, 3])</pre><pre>t[1].append(4)<br>print(t)</pre><pre>(1, [2, 3, 4])</pre><p>The tuple itself is immutable, but it can <strong>reference mutable objects</strong>.</p><h3>Why This Matters (and How Python Treats Them Differently)</h3><p>Understanding mutability explains:</p><ul><li>unexpected side effects</li><li>shared state bugs</li><li>performance characteristics</li></ul><p>Example pitfall:</p><pre>def add_item(lst, item):<br>    lst.append(item)</pre><pre>items = []<br>add_item(items, &quot;A&quot;)<br>print(items)</pre><pre>[&#39;A&#39;]</pre><p>This may be intended — or a bug — depending on expectations.</p><p>Compare with immutable behavior:</p><pre>def add_one(n):<br>    n += 1</pre><pre>x = 5<br>add_one(x)<br>print(x)</pre><pre>5</pre><p>The original integer is untouched.</p><p>Python optimizes immutable objects aggressively (interning, caching), while mutable objects emphasize flexibility.</p><h3>How Arguments Are Passed to Functions</h3><p>Python uses <strong>call by object reference</strong> (sometimes called <em>call by sharing</em>).</p><p>What this means:</p><ul><li>the function receives a reference to the object</li><li>mutability determines whether changes are visible outside</li></ul><p>Mutable example:</p><pre>def modify_list(l):<br>    l.append(99)</pre><pre>nums = [1, 2, 3]<br>modify_list(nums)<br>print(nums)</pre><pre>[1, 2, 3, 99]</pre><p>Immutable example:</p><pre>def modify_int(n):<br>    n += 99</pre><pre>x = 1<br>modify_int(x)<br>print(x)</pre><pre>1</pre><p>Same passing mechanism — different result because of mutability.</p><p>A classic trap with default arguments:</p><pre>def bad_function(lst=[]):<br>    lst.append(1)<br>    return lst</pre><pre>print(bad_function())<br>print(bad_function())</pre><pre>[1]<br>[1, 1]</pre><p>The default list is created <strong>once</strong>, not per call.</p><p>Correct version:</p><pre>def good_function(lst=None):<br>    if lst is None:<br>        lst = []<br>    lst.append(1)<br>    return lst</pre><h3>What I Learned from the Advanced Tasks</h3><p>In the advanced tasks, I went deeper into:</p><ul><li>object caching and interning (small integers, strings)</li><li>identity vs equality (is vs ==)</li><li>how reassignment differs from in‑place modification</li><li>how CPython optimizations affect id() behavior</li></ul><p>Example:</p><pre>a = 256<br>b = 256<br>print(a is b)</pre><pre>c = 257<br>d = 257<br>print(c is d)</pre><p>Depending on the implementation, results may differ, reinforcing why <strong>is should only be used for identity checks (like </strong><strong>None)</strong>.</p><h3>Conclusion</h3><p>Everything in Python is an object, but not all objects behave the same. Understanding <strong>identity, type, mutability, and argument passing</strong> is essential for writing correct, predictable, and efficient Python code. These concepts are not academic — they directly affect how your programs behave in production.</p><p>Mastering them turned many of Python’s “surprises” into clear, logical outcomes.</p><p>Github: <a href="https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations">https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be6a120b5393" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Do SQL Database Engines Work?]]></title>
            <link>https://medium.com/@suleyman.hacizade1/how-do-sql-database-engines-work-3b76384513c5?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b76384513c5</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[sql-server]]></category>
            <category><![CDATA[sql-injection]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Sun, 23 Nov 2025 11:13:18 GMT</pubDate>
            <atom:updated>2026-06-26T10:35:40.557Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*8WrSK_knx9k1EpHQ.jpeg" /></figure><h3><em>Illustration of how a SQL database engine processes queries (simplified)</em></h3><h3>Introduction</h3><p>If you’ve ever used apps like Gmail, Netflix, or your bank’s website, you’ve interacted with databases — though probably without noticing it. At the heart of these apps is the SQL database engine: software that stores, retrieves, and manages data efficiently.</p><p>Think of a SQL database engine as a super-organized librarian. It knows where every book (data) is stored, how to quickly retrieve it, and how to handle multiple people trying to read or write at the same time.</p><h3>How SQL Engines Work</h3><p>A SQL database engine has several key components:</p><h3>1. Query Parser</h3><p>The parser validates the syntax of your SQL query.</p><pre>SELECT name, age FROM employees WHERE department = &#39;HR&#39;;</pre><p>The parser ensures that SELECT, FROM, and WHERE are used correctly.</p><h3>2. Query Optimizer</h3><p>The optimizer determines the most efficient way to execute a query.</p><ul><li>Chooses which indexes to use</li><li>Decides whether to scan the whole table or only parts</li><li>Determines the join order for multiple tables</li></ul><p><strong>Example:</strong></p><p>Suppose the employees table has 1,000,000 records but an index on department. The optimizer will use the index instead of scanning every row.</p><h3>3. Execution Engine</h3><p>Executes the query plan, retrieves data, applies filters, joins tables, and prepares the final result.</p><h3>4. Storage Engine</h3><p>Manages how data is physically stored on disk.</p><ul><li><strong>MySQL example:</strong></li><li>InnoDB → supports transactions and row-level locking</li><li>MyISAM → faster reads, no transactions</li></ul><h3>5. Transaction Manager</h3><p>Ensures data consistency when multiple users read/write simultaneously.</p><p>Implements <strong>ACID properties</strong>:</p><ul><li><strong>Atomicity:</strong> All changes happen or none at all</li><li><strong>Consistency:</strong> Database remains valid</li><li><strong>Isolation:</strong> Transactions don’t interfere with each other</li><li><strong>Durability:</strong> Committed changes are permanent</li></ul><h3>Example Scenario</h3><p>Imagine a library database with two tables: books and authors.</p><pre>CREATE TABLE authors (<br>    id INT PRIMARY KEY,<br>    name VARCHAR(100) NOT NULL<br>);</pre><pre>CREATE TABLE books (<br>    id INT PRIMARY KEY,<br>    title VARCHAR(100) NOT NULL,<br>    author_id INT,<br>    FOREIGN KEY (author_id) REFERENCES authors(id)<br>);</pre><pre>INSERT INTO authors VALUES (1, &#39;J.K. Rowling&#39;), (2, &#39;George Orwell&#39;);<br>INSERT INTO books VALUES (1, &#39;Harry Potter&#39;, 1), (2, &#39;1984&#39;, 2);</pre><p>We want to list all books with their author names:</p><pre>SELECT b.title, a.name<br>FROM books b<br>JOIN authors a ON b.author_id = a.id;</pre><p><strong>Engine steps:</strong></p><ol><li><strong>Parser</strong> validates SQL syntax</li><li><strong>Optimizer</strong> chooses the best join order and uses the PRIMARY KEY index</li><li><strong>Execution Engine</strong> performs the join and fetches results</li></ol><p><strong>Result:</strong></p><p>title name Harry Potter J.K. Rowling 1984 George Orwell</p><h3>How Indexes Help</h3><p>Indexes are like a library catalog. Without them, the engine would scan every row.</p><pre>CREATE INDEX idx_author_id ON books(author_id);</pre><p>Looking up all books by author_id=1 becomes much faster with this index.</p><h3>Concurrency &amp; Transactions</h3><p>If two people borrow the same book at the same time, the engine ensures one transaction doesn’t overwrite the other.</p><h3>Summary</h3><p>A SQL database engine is more than just storage. It:</p><ul><li>Parses queries</li><li>Optimizes execution plans</li><li>Executes queries efficiently</li><li>Manages storage</li><li>Handles transactions and concurrency</li></ul><p>With the right indexes and optimized queries, databases can handle millions of records efficiently.</p><h3>Next Steps</h3><ul><li>Create a small MySQL database with authors and books</li><li>Experiment with indexes and EXPLAIN SELECT ...</li><li>Observe performance differences with and without indexes</li></ul><p>Github: <a href="https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations">https://github.com/SuleimanHajizadeh/holberton-computer-science-foundations</a></p><h3>References / Resources</h3><ul><li>MySQL official documentation: <a href="https://dev.mysql.com/doc/">https://dev.mysql.com/doc/</a></li><li>SQL Performance Basics: <a href="https://use-the-index-luke.com/">https://use-the-index-luke.com/</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b76384513c5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Complete Beginner-to-Advanced Guide to MEGA Software for Molecular Evolution and Phylogenetic…]]></title>
            <link>https://medium.com/@suleyman.hacizade1/a-complete-beginner-to-advanced-guide-to-mega-software-for-molecular-evolution-and-phylogenetic-ae7c3777102b?source=rss-69b74117fec7------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae7c3777102b</guid>
            <category><![CDATA[mega-software]]></category>
            <category><![CDATA[bioinformatics]]></category>
            <dc:creator><![CDATA[Suleiman Hajizadeh]]></dc:creator>
            <pubDate>Sun, 16 Nov 2025 00:50:26 GMT</pubDate>
            <atom:updated>2026-03-09T06:45:58.959Z</atom:updated>
            <content:encoded><![CDATA[<h3>A Complete Beginner-to-Advanced Guide to MEGA Software for Molecular Evolution and Phylogenetic Analysis (With My GitHub Resources)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/459/1*2t7qFgcMr_E5byLGN1sYEQ.png" /></figure><p>Understanding the evolutionary relationships between organisms is one of the most fundamental goals of modern biology. Whether you are comparing viral genomes, building phylogenetic trees, analyzing genetic mutations, or studying population history, you need reliable computational tools.</p><p>One of the best and most accessible tools available today is <strong>MEGA — Molecular Evolutionary Genetics Analysis software</strong>. MEGA has become a standard program in evolutionary biology because it combines powerful algorithms with a simple, friendly interface.</p><p>In this detailed guide, I will walk you through:</p><ul><li>What MEGA is and why it is widely used</li><li>How phylogenetic and evolutionary sequence analysis works</li><li>How to use MEGA step-by-step</li><li>How to interpret your results</li><li>How to practice analysis using my GitHub repository</li><li>Practical tips, common pitfalls, and workflow recommendations</li></ul><p>This article is designed for:</p><ul><li>Students who are new to molecular evolution</li><li>Researchers who need a quick introduction</li><li>Bioinformatics beginners</li><li>Anyone trying to build phylogenetic trees or analyze DNA/protein sequences</li></ul><p>By the end of this guide, you will be able to perform real evolutionary analyses and understand the logic behind them.</p><h3>Table of Contents</h3><ol><li>Introduction to Molecular Evolution and Phylogenetics</li><li>What Is MEGA Software?</li><li>Why MEGA Is Useful (Strengths &amp; Weaknesses)</li><li>Overview of My GitHub Repository</li><li>Installing MEGA and Preparing Your Workspace</li><li>Understanding Sequence Alignment</li><li>Practical Tutorial: Step-by-Step Analysis in MEGA</li><li>Choosing the Best Evolutionary Model</li><li>Building and Interpreting Phylogenetic Trees</li><li>Exporting, Documenting, and Sharing Your Results</li><li>Common Mistakes and How to Avoid Them</li><li>Final Thoughts and Next Steps</li></ol><h3>1. Introduction to Molecular Evolution and Phylogenetics</h3><p>At the core of molecular evolution lies a simple idea:</p><blockquote><strong><em>DNA and protein sequences carry evolutionary history inside them.</em></strong></blockquote><p>By comparing sequences, we can determine:</p><ul><li>How closely related organisms are</li><li>When they diverged</li><li>How mutations accumulated</li><li>Which selective forces acted upon them</li></ul><p>This is the purpose of phylogenetics — to reconstruct evolutionary relationships using computational methods.</p><p>But to do this well, you need:</p><ul><li>high-quality sequence alignment</li><li>a good evolutionary model</li><li>a reliable method for tree construction</li><li>clear visualization of results</li></ul><p>This is where MEGA shines.</p><h3>2. What Is MEGA Software?</h3><p>MEGA (Molecular Evolutionary Genetics Analysis) is a free, cross-platform bioinformatics program designed for:</p><ul><li>Multiple sequence alignment</li><li>Estimating evolutionary distances</li><li>Choosing substitution models</li><li>Constructing phylogenetic trees</li><li>Visualizing and editing trees</li><li>Computing genetic diversity and molecular statistics</li></ul><p>It supports key methods such as:</p><ul><li>Neighbor-Joining (NJ)</li><li>Maximum Likelihood (ML)</li><li>Minimum Evolution</li><li>UPGMA</li><li>Bayesian support (via external tools)</li></ul><p>MEGA is widely used in universities and research labs because:</p><ul><li>It works on Windows and macOS</li><li>It is beginner-friendly</li><li>It is visually intuitive</li><li>It supports professional-level analysis</li></ul><h3>3. Why MEGA Is Useful</h3><h3>Strengths</h3><p>Easy for beginners<br> Good visualization tools<br> Many built-in models<br> Great for teaching &amp; labs<br> Free for academic use<br> Works well for small to medium datasets</p><h3>Limitations</h3><p>Not ideal for whole-genome datasets<br> No command-line version for automation<br> Advanced users may prefer IQ-TREE, RAxML, BEAST</p><p>However, for learning, teaching, and hundreds of real research tasks, MEGA is more than enough.</p><h3>4. Overview of My GitHub Repository</h3><p><strong>GitHub Repository:</strong><br> <a href="https://github.com/SuleimanHajizadeh/MEGA-Software-Molecular-Evolutionary-Genetics-Analysis">https://github.com/SuleimanHajizadeh/MEGA-Software-Molecular-Evolutionary-Genetics-Analysis</a></p><p>I created this repository to help learners and researchers practice MEGA more effectively.<br> Inside the repository you will find:</p><h3>Provided Folders</h3><ul><li><strong>MEGA_12</strong> — Example analysis setups</li><li><strong>Mega(experience)</strong> — My personal practice datasets</li><li><strong>TRO_Seq</strong> — Real sequence files for alignment and tree building</li></ul><h3>Provided Files</h3><ul><li>DNA FASTA sequences</li><li>Alignment examples</li><li>Tree output examples</li><li>MEGA project files (.meg)</li><li>Notes and documentation</li></ul><p>This repository serves as a <strong>hands-on learning kit</strong> for molecular evolution.</p><h3>5. Installing MEGA and Preparing Your Workspace</h3><h3>Step 1 — Download MEGA</h3><p>Visit: <a href="http://www.megasoftware.net/"><strong>www.megasoftware.net</strong></a></p><p>Choose your platform: Windows or macOS.</p><h3>Step 2 — Clone or Download the Repository</h3><pre>git clone https://github.com/SuleimanHajizadeh/MEGA-Software-Molecular-Evolutionary-Genetics-Analysis</pre><p>or simply “Download ZIP” from GitHub.</p><h3>Step 3 — Open MEGA</h3><p>After installing MEGA:</p><ul><li>Launch the software</li><li>Familiarize yourself with the menus</li><li>Open the “Alignment Explorer” window</li></ul><p>You are ready to begin.</p><h3>6. Understanding Sequence Alignment</h3><p>Before building any phylogenetic tree, you must align the sequences.</p><blockquote><strong><em>Alignment ensures that homologous positions match across sequences.</em></strong></blockquote><p>MEGA offers two main algorithms:</p><p>Algorithm Description <strong>ClustalW</strong> Classic alignment, stable results <strong>MUSCLE</strong> Faster and more accurate for most datasets</p><p>Bad alignment = bad phylogenetic tree.</p><p>So alignment is the most important step in the entire workflow.</p><h3>7. Practical Tutorial: Step-by-Step Analysis in MEGA</h3><p>Below is a complete example you can follow using files from the TRO_Seq folder.</p><h3>Step 1 — Load Sequences</h3><p>Open:</p><p><strong>Align → Edit/Build Alignment → DNA → Open File</strong></p><p>Load a FASTA file from the repository.</p><h3>Step 2 — Perform Multiple Sequence Alignment</h3><p>Choose:</p><p><strong>Alignment → Align by MUSCLE (or ClustalW)</strong></p><p>MEGA will align the sequences automatically.</p><p>Check for:</p><ul><li>Large gaps</li><li>Ambiguous regions</li><li>Misaligned codons</li></ul><p>If necessary, manually edit the alignment.</p><h3>Step 3 — Save the Alignment</h3><p>Click:</p><p><strong>Data → Export Alignment → MEGA format (.meg)</strong></p><p>This file type stores your alignment for tree construction.</p><h3>Step 4 — Choose an Evolutionary Model</h3><p>Before building a tree, MEGA must understand how mutations occur.</p><p>Go to:</p><p><strong>Models → Find Best DNA/Protein Models</strong></p><p>MEGA will rank models based on AIC/BIC scores.</p><p>Common models include:</p><ul><li>GTR (General Time Reversible)</li><li>HKY</li><li>TN93</li><li>JC69</li></ul><p>Your tree’s accuracy depends heavily on choosing the correct model.</p><h3>Step 5 — Build a Phylogenetic Tree</h3><p>Go to:</p><p><strong>Phylogeny → Construct Maximum Likelihood Tree</strong></p><p>or choose alternative methods like Neighbor-Joining.</p><p>Configure:</p><ul><li>Substitution model</li><li>Bootstrap replicates (recommended: 500–1000)</li><li>Gaps handling</li></ul><p>Click <strong>Compute</strong>.</p><p>MEGA generates your phylogenetic tree.</p><h3>Step 6 — Visualize the Tree</h3><p>You can adjust:</p><ul><li>Branch lengths</li><li>Bootstrap values</li><li>Node labels</li><li>Tree layout (rectangular, radial, circular)</li></ul><p>This helps make your tree publication-ready.</p><h3>Step 7 — Export Results</h3><p>MEGA allows:</p><ul><li>Export tree image (PNG/SVG)</li><li>Save alignment</li><li>Save tree session (.mts)</li><li>Export Newick format for use in IQ-TREE, RAxML, etc.</li></ul><p>You can upload these files to GitHub or include them in your research.</p><h3>8. Choosing the Best Evolutionary Model</h3><p>Evolutionary models describe how mutations occur.</p><p>A good model leads to:</p><ul><li>Accurate branch lengths</li><li>Correct tree topology</li><li>Reliable bootstrap support</li></ul><p>MEGA uses model-selection metrics:</p><ul><li><strong>AIC (Akaike Information Criterion)</strong></li><li><strong>BIC (Bayesian Information Criterion)</strong></li></ul><p>Tip: choose the model with the <strong>lowest score</strong>.</p><h3>9. Building and Interpreting Phylogenetic Trees</h3><p>Understanding your tree is as important as building it.</p><p>Look for:</p><h3>Clustering patterns</h3><p>Species with high similarity cluster together.</p><h3>Branch lengths</h3><p>Long branches = more mutations.</p><h3>Bootstrap values</h3><p>Confidence measure of branch reliability (0–100%).</p><h3>Outgroups</h3><p>Helps root the tree correctly.</p><p>For beginners, I recommend:</p><ul><li>Use 1000 bootstrap replicates</li><li>Use MUSCLE for alignment</li><li>Choose ML (Maximum Likelihood) for tree building10. Exporting, Documenting, and Sharing Your Results</li></ul><p>After constructing your tree:</p><h3>Export Options:</h3><ul><li><strong>PNG</strong> — easy for figures</li><li><strong>SVG</strong> — best for editing in Illustrator</li><li><strong>Newick file</strong> — share with other bioinformatics tools</li><li><strong>MEGA session</strong> — lets you continue analysis later</li></ul><p>Good scientific practice:</p><ul><li>Save your alignment</li><li>Save your MEGA project</li><li>Upload results to GitHub or lab folder</li><li>Document your parameters (model, alignment, bootstrap)</li></ul><h3>11. Common Mistakes Beginners Make</h3><h3>Using unaligned sequences</h3><p>Fix: Always align before building a tree.</p><h3>Using the wrong evolutionary model</h3><p>Fix: Run model test first.</p><h3>Interpreting bootstrap incorrectly</h3><p>Fix: Values above 70% are generally reliable.</p><h3>Editing sequences manually without reason</h3><p>Fix: Do not “fix” mutations unless you know they are sequencing errors.</p><h3>Too many gaps</h3><p>Fix: Trim badly aligned regions.</p><h3>12. Final Thoughts: Start Your Own Evolutionary Project</h3><p>MEGA is one of the best tools for learning molecular evolution because:</p><ul><li>It is free</li><li>Easy to use</li><li>Scientifically accurate</li><li>Great for teaching and real research</li></ul><p>My GitHub repository is designed to help you practice with real datasets, explore alignments, and build your first phylogenetic trees without confusion.</p><p><strong>If you want to learn molecular evolution — start with MEGA.</strong><br><strong>If you want hands-on practice — use my GitHub datasets.</strong></p><p>I encourage you to:</p><p>Star the repository<br> Fork it<br> Contribute issues<br> Share your own datasets<br> Build and explore your own phylogenetic trees</p><p>This is the best way to master evolutionary genetics analysis.</p><h3>About the Author</h3><p>I’m <strong>Suleyman</strong>, a biology student interested in molecular evolution, bioinformatics, phylogenetics, and computational genomics. I create resources that make scientific learning easier for beginners and researchers.</p><p>You can connect with me on GitHub for future projects and collaborations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae7c3777102b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>