Building a Lexer from Scratch with C and Flex

✨ Tiny Scanner and Parser Project - Compiler Design Excited to share one of the most enjoyable projects I have worked on. As part of our Compiler Design course, we built a Tiny Language Scanner and Parser using C++ and Qt to understand how a compiler analyzes source code step by step. 🔍 Project Overview ✅ Scanner • Takes Tiny language source code as input • Converts it into tokens (keywords, identifiers, numbers, operators) ✅ Parser • Receives tokens generated by the scanner • Verifies that the code follows the defined grammar rules • Builds and visualizes the syntax tree This project benefited me greatly and helped me gain a clear understanding of how compilers work internally and how source code is transformed into structured representations. 🙏 Big thanks to my teammates for the great teamwork throughout the project. Toqa Gamal, Jana Wael, Nouran Salah, Marina Mokhtar, Sama Ahmed 🤩 Looking forward to learning more about compiler design! 🔗 GitHub Repository https://lnkd.in/dsqppX62 #CompilerDesign #Scanner #Parser #TinyLanguage #Cplusplus #Qt #Programming #TeamWork #ContinuousLearning

Creating a new programming language completely from scratch, in just two weeks. About a year ago, I had an idea for a programming language called Stride. It sat on the shelf for a while, but about 2 weeks ago, I finally regained the motivation to see if I could actually make it work (again...). I started typing, and sooner or later, I had a working prototype. Stride is currently JIT-compiled using the LLVM compiler toolchain. By leveraging LLVM’s optimization passes, the current implementation is already performing significantly faster than I expected for an early-stage project. Beyond the compiler itself, I also built a web-based editor with syntax highlighting. I’ve always felt that the environment where you write code is just as important as the code itself, so I wanted to make sure the "feel" of the language was right from the start. This project has been a deep dive into the internals of compilers and low-level architecture. It’s still early, but the foundation is there. If you’re interested in compilers or C++, or just improving the language cause you think it looks cool, feel free to have a look, leave a suggestion, or even open a PR. You can find the repository here: https://lnkd.in/ekjCJTA8

🚀 Day 58 of My DSA Challenge Today was all about diving deeper into Object-Oriented Programming in C++ and strengthening my core concepts that build the backbone of scalable software. 🔹 Concepts I explored: Shallow Copy vs Deep Copy: Also learn why we create the copy constructor as we have a compiler, but understand that copy constructors are being created for the deep copy, as compilers only create a shallow copy of the constructor. Constructors & Destructors Inheritance Modes (public, private, protected) Types of Inheritance: ▪ Single ▪ Multilevel ▪ Hierarchical ▪ Multiple ▪ Hybrid Understanding these concepts made me realize the power of OOP design in writing clean, reusable, and maintainable code. The deeper I go, the more I appreciate how these fundamentals shape real-world systems. #DSAChallenge #Day58 #CPP #OOPS #CodingJourney #LearningInPublic

🦾 For the past few months, I’ve been quietly building Pine My own statically typed programming language, from the ground up. It’s one thing to use a language; it’s another to build the compiler that makes it run. It compiles to native binary and runs at near native speed. It successfully compiled a full arithmetic suite—handling functions, stack variables, and multi-parameter logic—lowered it to LLVM-IR, and executed it to return the correct result. The Pine Toolchain (pinec) now handles: Lexical Analysis: Breaking source code into tokens. AST Generation: visualizing the logic tree (exported to .dot files). LLVM-IR Generation: Translating the AST into intermediate representation. Compilation: Building the final binary. Here’s a sample Pine program that now compiles and runs correctly: fn main() -> i32 { let sum: i32 = add(10, 20); let diff: i32 = sub(mul(10, 2, 2), 10); let mul: i32 = mul(1, 2, 3); let div: i32 = div(8, 4); return sum + diff + mul + div; } Output: 68 This is just the beginning. Pine started as a way to truly understand how programming languages work beneath the surface, and it’s now a solid foundation to explore deeper territory—control flow, richer type systems, optimizations, and beyond. Building a compiler changes how you think about code forever, and Pine is my playground for that journey. Excited to keep pushing it forward and see how far it can go 🌲 pine: https://lnkd.in/gpPppbXG #Compilers #ProgrammingLanguages #LLVM #RustLang #SystemsProgramming #LearningInPublic #OpenSource

Why can’t you index a string in Rust? If you’ve ever written `my_string[0]` and hit a compiler error, you’re not alone. This isn’t a Rust limitation — it’s a deliberate design choice. Rust strings are UTF-8 encoded, which means: • Characters are variable-width • Indexing would be misleading and unsafe • Performance guarantees would break In my latest video, I explain: – Why Rust forbids string indexing – How UTF-8 actually works under the hood – The difference between `String` and `&str` – The correct and idiomatic ways to work with strings This is part of my Rust debugging series focused on real pain points developers face when transitioning to Rust. 👉 Video link in the comments. #Rust #RustLang #RustProgramming #SystemsProgramming #MemorySafety #UTF8 #SoftwareEngineering #Programming

I solve the Zip Game daily on LinkedIn, and one day I had an idea Instead of solving it manually, I wondered: “Can this puzzle be solved programmatically using backtracking?” That curiosity led me to implement a Zip Board Game Solver in Java using a DFS + backtracking approach. Problem Description: The objective is to connect nodes (numbered 1 to N) in incremental order.  The solution must satisfy the following rules: - Orthogonal Movement: You can only move Up, Down, Left, or Right. - Sequential Continuity: A path to node X must originate exactly from node X-1. - Hamiltonian Constraint: Every single cell in the grid must be occupied by either a node or a path segment. - Cell Exclusivity: No overlapping or crossing of paths is allowed. The time complexity is exponential, which is expected for this kind of constraint-based pathfinding problem — but pruning, early termination, and sequential constraints make it practical for small grids. GitHub Repository:https://lnkd.in/g6bGPSQR Would love to hear thoughts or optimization ideas from the community! #Java #Backtracking #Algorithms #ProblemSolving #LearningByDoing #DFS #Projects

🚀 Stop Writing Old-School Switch Statements! If you are still using the traditional switch with constant case and break keywords, you are missing out. C# Pattern Matching is a true game-changer for writing Clean Code. Why use Switch Expressions? 🔵 Conciseness: Reduces boilerplate significantly. 🔵 Readability: Expresses logic declaratively. 🔵 Safety: Better compiler checks for exhaustiveness. ⚡ Key Patterns to Master: 1️⃣ Relational: Use <, >, <= directly in logic. 2️⃣ Property: Match object properties { Status: "Active" }. 3️⃣ List Patterns (C# 11): Match arrays like [1, 2, ..]. Level up your C# and start using Pattern Matching today! #CSharp #DotNet #CleanCode #Programming #SoftwareEngineering #Backend

LeetCode is HARD until you Learn these 15 Patterns: 1. Prefix Sum 2. Two Pointers 3. Sliding Window 4. Fast & Slow Pointers 5. LinkedList In-place Reversal 6. Monotonic Stack 7. Top ‘K’ Elements 8. Overlapping Intervals 9. Modified Binary Search 10. Binary Tree Traversal 11. Depth-First Search (DFS) 12. Breadth-First Search (BFS) 13. Matrix Traversal 14. Backtracking 15. Dynamic Programming Patterns

If you’ve written Rust for more than 10 minutes, you’ve probably met this one: ❌ error[E0502]: cannot borrow as mutable because it is also borrowed as immutable Confusing? Frustrating? Absolutely 😤 But once it clicks, Rust starts making way more sense. In my latest video, I break down this infamous Rust error from first principles, without compiler jargon overload. 🎯 What this video covers: • What mutable vs immutable borrowing really means • Why Rust refuses to compile code that “looks correct” • Common real-world patterns trigger this error • How to restructure code instead of fighting the borrow checker • Mental models that help you avoid this error permanently This isn’t just about fixing one error — it’s about thinking in Rust. If the borrow checker ever made you stare at the screen questioning your intelligence… trust me, this video is for you 😄 📺 Watch the full video here: 👉 [link in comments] #Rust #RustLang #BorrowChecker #SystemsProgramming #ErrorHandling #Programming #SoftwareEngineering #LearningRust