DEV Community: stungnet

Why Every Developer Should Consider the Linux & Neovim Leap

stungnet — Sun, 17 Sep 2023 04:42:04 +0000

When I first began coding, few things were as intimidating as confronting a barrage of error messages in the terminal. Attempting to decipher these messages and pinpoint my missteps felt overwhelming. This initial experience instilled in me a genuine apprehension towards the terminal. It appeared far more intricate compared to my then-favored IDE, VSCode. Within VSCode, running code was as simple as a click of a button. For Git operations, a user-friendly GUI on the side shielded me from the underlying complexities. Moving, creating, copying, renaming files done with the click of my mouse. While these abstractions seemed helpful on the surface, they inadvertently fostered a superficial understanding. I felt confident, believing I had grasped the nuances of what I was doing. In reality, my comprehension of the terminal and its intricacies remained elementary.

Needing Change

VSCode's comforts, once my sanctuary, started feeling more like a limitation. Whenever I faced challenges needing deeper system interactions or more nuanced controls, I'd dodge or find workarounds. Habitually, I'd resort to Stack Overflow, blindly copying solutions. This makeshift approach held until a project showcased my shortcomings. Up against a merge conflict, while my IDE hesitated, my colleague tackled it effortlessly using the terminal. This vivid contrast was a wake-up call that to grow, I needed to learn the terminal.

Turning Point

With this realization, I embarked on a quest to understand the terminal. My research led me to two pivotal decisions: transitioning to Linux and adopting Neovim. The appeal of Linux lay in its terminal-centric design; it compelled daily terminal interactions, something I've come to appreciate deeply. Neovim's allure came from an eye-opening video by ThePrimeagen titled "My Developer Workflow - How I use i3, tmux, and vim." His seamless window navigation with i3 and rapid file transitions were nothing short of mesmerizing.

If he so happens to read this, thanks for your constant content, vim btw.

Into the Terminal

Linux: Transitioning from Windows to Ubuntu felt like navigating a maze. The initial days were filled with challenges: from decoding unfamiliar directories to wrestling with package installations. But, configuring i3 opened up a new realm of efficient window management, while tmux elevated my terminal game. By embracing these tools, what began as a daunting journey transformed into a masterclass in seamless navigation and multitasking. Ubuntu became less of an OS to adapt to and more of a playground.
Neovim: Starting with Neovim was an adventure on its own. I chose the path less taken by avoiding pre-built configurations. Sure, it made my journey steeper than most, but the satisfaction? Unparalleled. I remember the euphoria of setting up my first plugin manager, tweaking the theme, and personalizing options. Every step felt like a revelation. While VSCode offered convenience, Neovim gave me control. But beyond its capabilities, what bolstered my Neovim experience was its incredible community. The /r/neovim subreddit became an invaluable resource for me, teeming with enthusiasts who were ever-ready to help, share, and guide. Each plugin I added, each configuration I tweaked, required research and decision-making. And clicking 'install' on VSCode just couldn't replicate that deep sense of engagement. After about a week of immersing myself, not only did I craft a working config I was proud of, but I also picked up a bit of Vimscript and Lua, thanks in part to the collective knowledge of the Neovim community.

Looking Back, Looking Forward

In another blog post last week, I talked about how diving deep into Data Structures and Algorithms profoundly enhanced my coding skills. Similarly, my expedition within the terminal has reshaped my perspective. The more time I invested in this environment, the more intuitive it became. I've grown adept with key bindings and configuring to my liking. Currently, my arsenal comprises i3, Neovim, and Ubuntu. Coding on any other OS now feels like a step back; I miss that seamless dance between windows and tasks.

A list of benefits I've seen:

Mouse-Free Productivity: I find myself rarely using the mouse now. Engaging deeply with my code without switching between keyboard and mouse feels more fluid and immersive.
Decoding Errors with Ease: Lengthy error messages that once overwhelmed me now seem more navigable. My relationship with them has evolved into one of understanding.
Unveiling System Depths: Venturing into the terminal, I've gained a deeper grasp of the foundational technologies that govern our digital realms.
Tailored Workspace: The power to mold and customize my environment to my exact liking is liberating. Every detail is a reflection of my preferences.
Rapid File and Window Transitions: My productivity has soared due to the swift navigation between files and windows. Every second saved compounds over the course of a project.

Some potential pitfalls:

Over-customization: The ability to tailor every detail can lead you down the rabbit hole of relentless tweaking. There's the temptation to perfect your config continuously. My advice? Once you have it in a functional, productive state, let it be for a month or so before revisiting. Nowadays, I rarely make changes to mine.
Steep Learning Curve: Diving into Linux or Neovim can be daunting for those accustomed to more user-friendly interfaces. The initial investment in learning can be high.

I wanted to share this journey with you because diving into Linux and Neovim opened new doors for me in coding. I genuinely believe they can offer you some fresh perspectives and tools, making coding even more enjoyable and efficient. Give it a whirl; it might just be the game-changer you didn't know you needed.

A Guide to Getting Started:

If this post has peaked your interest in wanting to take that step into the terminal this list should do you well:

Ubuntu Installation : I use Learn Linux TV for all my Linux needs, he does great content - Ubuntu 22.04 LTS - Full Installation Walkthrough

Neovim:
- Prebuilt Configs ‒ If you want to just test out Neovim without going through the configuration yourself you can start with a prebuilt config:
  - LazyVim: Where I would start with prebuilt: LazyVim
    - A guide looking at the LazyVim setup: Zero to IDE with LazyVim
  - LunarVim: LunarVim
  - NvChad: NvChad
  - AstroVim: Getting Started | AstroNvim
- Setting up your own config guides:
  - TJ DeVries: Effective Neovim: Instant IDE - YouTube ‒ One of the Neovim contributor greats, taking you to an instant IDE.
  - ThePrimeagen : 0 to LSP : Neovim RC From Scratch - YouTube ‒ Honestly just watch all his videos regarding vim/neovim, this is his most recent on setting up a config.
  - Chris@machine : Neovim IDE from Scratch - Introduction (100% lua config) ‒ Chris is the creator of LunarVim, this is where I started content wise I'm not sure how up to date it would be now, but still worth the mention.
  - Josean Martinez: Josean Martinez - YouTube ‒ Recently dropping some new content, his tutorials are worth the watch if you want to set your own up.
  - Deams of Code: Dreams of Code - YouTube ‒ Has a couple of specific Neovim configuration setups, including (Python, NodeJS, Golang, Rust)
  - Devaslife: How to set up Neovim for coding React, TypeScript, Tailwind CSS, etc on a new M2 MacBook Air ‒ Might be a bit dated but I love his video styles.
- Learning to navigate in Vim:
  - Vim As Your Editor: Vim As Your Editor - Introduction ‒ Series by ThePrimeagen
- Helpful links
  - rockerBOO/awesome-neovim: Collections of awesome neovim plugins. ‒ RockerBOO has a repo that has almost every plugin for Neovim by category, this is a gold mine.
  - /r/neovim any questions go here the community is very welcoming and helpful.
  - Home - Neovim ‒ Neovim site
  - neovimcraft ‒ Site related to configs and plugins available
  - This Week in Neovim - Neovim news
- Some Config Examples
  - Mine : link
  - ThePrimeagan: link
  - folke: link
  - josean-dev: link

If you found value in this post, please give it a like or drop a comment. Your feedback helps and is much appreciated. Happy coding!

The Silent Power of Data Structures and Algorithms - A Developer's Guide

stungnet — Fri, 08 Sep 2023 00:29:37 +0000

"Algorithms are the 'thought processes' of software." - Adam Osborne

Introduction

In the realm of Computer Science, the study and analysis of algorithms and data structures (DSA) stands as a foundational pillar. If your journey was anything like mine, formal education might not have been the path you took. I learned to code the way many of us do: by simply diving in and coding. Without the structured guidance of a university course, I charted my own course, hopping from one tutorial to another and building applications along the way. For a while, I believed I was on top of my game. That was until I encountered the intricate world of DSA. It was a humbling revelation, making me realize that my understanding was still in its infancy. But from this point, I began a deeper exploration into DSA. In this blog post, I aim to share why DSA is so pivotal and how it can elevate your skills as a developer.

If you want to skip and see the list click here

What's An Algorithm? Think Gym Routine.

Remember the first time you stepped into a gym? The vast array of equipment and exercises could be overwhelming. Then perhaps you met a trainer, or found a workout plan online, detailing a specific sequence: "10 squats, 15 push-ups, 3 sets of bicep curls." That's your algorithm in action—a carefully planned sequence ensuring you efficiently work towards your fitness goals. Rather than randomly hopping from one machine to the next and risking ineffective workouts (or worse, an injury), algorithms provide a structured plan to tackle problems with finesse and precision.

Data Structures? Picture This.

Ever been to one of those trendy salad bars where you can mix and match ingredients? There are separate containers for lettuce, tomatoes, olives, and so on. You wouldn’t want to fish for feta cheese in a tub mixed with olives and cucumbers, right? Data structures operate on a similar principle. They’re like those individual containers, ensuring data is stored neatly and accessibly. So, when you need a specific ingredient (or piece of data), you know exactly where to look without diving through a chaotic mix.

The Real-World Impact of DSA

You see, once I had these "aha!" moments about DSA, coding no longer felt like blind trial and error. It was like having a gym routine tailor-made for every project. The algorithms became my exercise plans, ensuring that every line of code was working efficiently towards the goal. And data structures? They became the organizational system I never knew I needed, much like those separate containers at salad bars keeping everything tidy.

"The algorithm is where you write down the solution to your problem. The data structure is what carries this solution around and makes it effective." - Scott Meyers

Why Should You Care About DSA?

To those who’ve never set foot in a gym or bothered about salad bar organization, you might be wondering, "Why does any of this matter for coding?" Well, just as a well-structured gym routine can be the difference between building muscle or merely sweating it out, understanding DSA can differentiate a good developer from a great one.

In practical coding projects, you're often faced with decisions: How to store user data? Which method to use when searching for specific information? How to ensure that your app runs swiftly, even when faced with tons of data? That’s where DSA shines. Algorithms give you efficient methods to process data, while data structures offer optimal ways to store and retrieve it.

The Learning Curve – It’s Worth the Climb

I won't sugarcoat it: diving into DSA felt like my first week at the gym all over again. There was unfamiliar terminology, complex concepts, and moments of sheer frustration. But much like persisting with a gym routine brings visible results, investing time into DSA has sharpened my coding skills.

Embarking on the DSA Adventure: My Recommendations So Far

Before we dive into this list, there's something I'd like to make clear: I'm still very much on my own journey with DSA. By no means do I claim to be an expert; I'm still navigating the intricacies and experiencing those 'aha!' moments every other day. However, during this exploration, I've stumbled upon some fantastic resources that have been instrumental in shedding light on the complex world of algorithms and data structures.

I believe in sharing as we learn. So, consider this list less of an 'ultimate guide' and more of a friendly nudge in the right direction—a collection of stepping stones from someone a few steps ahead, eager to lend a helping hand. I hope these recommendations serve you as well as they've served me!

Websites

Coursera - Specifically the Algorithms Specialization by Stanford University.
- Part 1
- Part 2
LeetCode - Perfect for practicing algorithms and data structure problems.
Neetcode - Resources related to algorithms and data structures.
HackerRank - Another platform for coding challenges and DSA practice.
MIT OpenCourseWare - Introduction to Algorithms is a gold standard.
- Introduction To Algorithms

YouTube

BroCode - Learn Data Structures and Algorithms for free
Pasan Premaratne and Jay McGavren - Algorithms and Data Structures Tutorial - Full Course for Beginners
Abdul Bari - Algorithms - Full Playlist
Steven from NullPointer Exception - Data Structures - Computer Science Course for Beginners
William Fiset - Data Structures Easy to Advanced Course - Full Tutorial from a Google Engineer

Books

"Introduction to Algorithms" - Widely considered the DSA bible. link
"Data Structures and Algorithms Made Easy" - Great for beginners. link
"Algorithms" - In-depth and comprehensive. link
"The Algorithm Design Manual" - Known for its real-world applicability. link
"Grokking Algorithms" - A more visual and beginner-friendly approach. link
"Cracking the Coding Interview" - DSA questions commonly asked in tech interviews. link
"Algorithm Design" - Great for gaining a deep understanding. link

Thanks for joining me on this DSA journey! If you found value in this post, please give it a like or drop a comment. Your feedback helps and is much appreciated. Happy coding!

From Wires to Wireless: Understanding LAN & WLAN in Your Home

stungnet — Sun, 03 Sep 2023 00:29:11 +0000

Introduction

Ever wondered about the magic that powers your home's or small office's internet? Every time you stream a movie, jump into a video call, or play an online game, you're using something special called a network. This is typically referred to as a SOHO (Small Office/Home Office) setup. Believe it or not, within this setup, you've probably established both a LAN and a WLAN, even if those terms sound a tad technical. But don't fret! In this blog post, we'll demystify these terms and guide you through understanding the network that's right within your walls. So, let's begin by defining these terms.

LAN (Local Area Network)

A LAN, or Local Area Network, is kind of like the hidden highways connecting all your digital devices in a close-knit space. Think of it as the behind-the-scenes magic that lets your computer talk to your printer or lets multiple computers share files. While LANs can sometimes span large areas like big corporate offices, for our chat today, let's picture the more cozy setting of your own home or a small office. Most of the time, these connections are made using cables – you might recognize the familiar blue Ethernet ones!

In the network diagram above, the switch plays the central role, directing communication among the various clients. This illustration showcases typical clients you might find in a LAN setup.

WLAN (Wireless Area Network)

A WLAN is just like a LAN but without the cables. Instead of using physical wires, devices connect using radio waves, often through Wi-Fi. Your smartphone, tablet, or laptop might connect to the internet without any cables, right? They're part of your home's WLAN, connecting wirelessly to a device often called a wireless router.

In the network diagram depicted, the wireless router stands as the linchpin, orchestrating wireless connections among a diverse array of devices. This visualization highlights the usual suspects in a WLAN environment: smartphones catching up on messages, laptops streaming videos and tablets downloading ebooks.

Devices

Now that we've laid the foundation with a clear understanding of what LAN and WLAN are, let's delve deeper into the intricacies of the setup. Specifically, we'll explore the devices that make it all possible, especially in the context of a SOHO (Small Office/Home Office) environment.

Wireless Router

When you think of connecting to the internet at home, the first device that probably comes to mind is the wireless router. It's that box with blinking lights that might be sitting on a shelf or behind your TV. But what's inside this magical box, and how does it do its job? Let's peel back the layers and explore its individual components.

D-Link wireless router: a compact yet powerful device, adept at ensuring a seamless Wi-Fi experience throughout your home.

Router

The word 'router' gives a hint about its main job – to 'route' or direct. Just as traffic lights ensure cars move smoothly on roads, a router directs digital traffic, making sure your online movie, email, or game reaches its destination without any hitches.

Check out the backbone of our office internet! This router might look complex with all its interfaces, but each one plays a part in keeping us connected. It's like a busy highway directing traffic!

Wireless Access Point

This component lets us break free from cables! It broadcasts wireless signals with a unique name, known as the SSID (Service Set Identifier). When you're trying to connect your smartphone, laptop, or TV and you see a list of Wi-Fi names? That's the SSID. By selecting the right one and entering a password (if required), your device can access the internet without being tethered by a cable.

Small but mighty! These little Cisco devices give you Wi-Fi in big places like offices. You might not always see them, but they're hard at work.

Switch

While the freedom of wireless connectivity from a wireless router is undoubtedly convenient, there's another crucial part of our network setup that comes into play when we use cables: the 'switch'. The switch is like the behind-the-scenes coordinator, ensuring devices within the same LAN chat with each other without needing to involve the router. So, when your computer and printer, both connected by cables, need to 'talk', it's the switch that makes the conversation happen seamlessly.

See this network switch? It's packed with ports, way more than our main router. While the router decides where data should go, this switch ensures all our devices can talk to each other. Think of it as the busy crossroads in our office's digital town.

For the sake of convenience and simplicity, manufacturers often bundle all these functionalities—router, switch, wireless access point—into one device that most people commonly refer to as a 'wireless router'. You might even hear some folks call it a 'modem' or just a 'router'. However, as we've learned, labeling it merely as a 'router' might be a tad oversimplified given its multi-faceted roles.

In the cozy confines of our homes or small offices, this all-in-one solution works beautifully. It's efficient, space-saving, and perfectly tailored to our needs. But when we step outside into the world of enterprise networks or expansive corporate setups, the story changes. Here, due to the sheer scale and specific requirements, these devices are typically standalone, each serving its unique purpose.

So, the next time you glance at your 'wireless router', remember: it's not just a simple box. It's a versatile powerhouse, deftly handling multiple roles, all designed to give you a seamless internet experience

Conclusion - SOHO Network Diagram

In wrapping up, visualizing our discussions, I've assembled a practical network diagram that embodies a typical SOHO LAN/WLAN setup using Packet Tracer. This illustration showcases a multifunctional wireless router at its heart, bridging both wired and wireless devices.

You'll notice two smartphones and a laptop seamlessly connecting via Wi-Fi, demonstrating the flexibility and convenience of wireless connections. Meanwhile, a computer and a printer, both integrated through Ethernet cables, exemplify the stability and speed of wired connections. Through this representation, I hope to demystify the intricate dance of devices on your home network. It's my aspiration that you now possess a clearer understanding of how each device interplays, ensuring you stay connected, whether you're printing a document, streaming a video, or simply browsing the web.

From Data to Frame: The Evolution of PDUs Across the OSI Model

stungnet — Sat, 26 Aug 2023 09:21:44 +0000

Introduction

In a recent exploration, I delved into the intricacies of the OSI model, detailing the distinct roles played by each layer throughout the networking stack. If you haven't had the chance to read that article, I recommend starting there Unpacking The OSI Model. Building on that foundation, this article aims to dive deeper, specifically focusing on the Protocol Data Units (PDUs) across the OSI layers – illuminating their operations and their crucial encapsulations. So let's commence, by starting at the layer you interact with the: Application Layer.

Application Layer (Layer 7) - Data

Within the Application Layer, the PDU is referred to simply as "Data". This data is raw and unstructured. Meaning it is the user's actual message, the file they're transferring, the content of the webpage they're accessing, or even the video they're streaming. As this data descends the networking stack, it undergoes layers of encapsulation, only to be de-encapsulated at its destination, reverting to its original, unadulterated form.

Presentation Layer (Layer 6) - Data

The PDU within the Presentation layer is still known as "Data", though the Data doesn't remain the same raw data we have in the Application Layer. This Data gets reformatted for compatibility, encrypted for security and compressed for transmission speed. The process here sets the stage for its journey further through the stack.

Session Layer (Layer 5) - Data

Within the Session Layer, our PDU is still recognized as "Data", marking its final appearance under this name. This layer is crucial in orchestrating the rhythm of communication: it not only establishes, maintains, and terminates sessions between two devices but also ensures the synchronization and structured management of the data being transferred. It's here that the mechanics of dialogue come into play, guaranteeing that the conversation between devices remains harmonious and coordinated.

Transport Layer 4 (Layer 4) - Segment/Datagram

At the Transport Layer, our PDU evolves distinctly, transitioning from the generalized "Data" to either "Segment" (within the realm of TCP) or "Datagram" (when dealing with UDP). This transformation is pivotal to end-to-end communication, as data is systematically divided into segments or datagrams for efficient transport, the PDU gains these essential attributes, encapsulated within what's known as the L4 Header.

Transport Layer Header (L4 Header):

Type of PDU: Data is categorized as either "Segment" (TCP) or "Datagram" (UDP).
Port Numbers: PDUs are endowed with source and destination port numbers to guide the data to its designated application.
Sequencing: Every PDU receives a unique sequence number, safeguarding the order of data upon its arrival.

Network Layer (Layer 3) - Packet

At the Network Layer, our evolving PDU gains another vital header, morphing it into what we recognize as a 'Packet'. This transformation isn't merely structural; the new header equips the packet with essential attributes to navigate the vast topology of interconnected networks. Specifically, it incorporates logical addressing (IP addresses), routing indicators, and other metadata that routers and switches utilize to determine the packet's optimal path through the network. This layer ensures that each packet, regardless of its source or the path it takes, will find its way to its intended destination.

Network Layer Header (L3 Header):

Logical Addressing: The introduction of source and destination IP addresses.
Lifetime Management: Incorporation of the TTL field.
Service Type Specification: The addition of the ToS field.
Header Integrity: Implementation of the header checksum.
Protocol Specification: Insertion of the protocol number.
Packet Size Management: Fragmentation and reassembly details added.

Data Link Layer (Layer 2) - Frame

At the Data Link Layer, our PDU is framed and readied for its voyage across the local network. This encapsulation introduces the frame's 'local address', guiding it toward its destination within the immediate network. Moreover, mechanisms such as error-checking ensure its safe transit.

Data Link Layer Header (Frame Header):

Source MAC Address: A unique identifier hardwired into the sending device's network interface card.
Destination MAC Address: The physical address of the intended recipient within the local network.
Type/Length Field: Indicates either the type of protocol encapsulated within or the frame's length.

Data Link Layer Trailer (Frame Trailer):

Frame Check Sequence (FCS): A CRC-based value, calculated from the frame's content, ensuring transmission accuracy.

Physical Layer (Layer 1) - Bits

Entering the foundational depths of our OSI journey, we reach the Physical Layer. Here, our meticulously crafted frame is translated into electrical pulses, optical signals, or radio waves, depending on the transmission medium. It's not about the content anymore; it's about the signal and its representation. This layer doesn't concern itself with headers or PDUs; it simply transmits raw binary data, one bit at a time.

Conclusion

As we journeyed through the OSI model, we've observed data undergoing encapsulation, layer by layer, prepped for its digital voyage. But this is only half the tale. For the end user to interact with this data, the reverse occurs. De-encapsulation systematically peels away the headers, restoring the data to its original form at the Application Layer.

However, it's worth noting that while the OSI provides a structured blueprint, it's primarily a conceptual model. In practice, data handling might not always align perfectly with each OSI layer's defined function. In every online exchange, it's these rapid, detailed processes that make our digital communications possible. Truly, it showcases the wonders of today's network technologies. Thank you for joining me on this exploration, and I appreciate your time spent reading!

In my upcoming blog post, I'll delve deeper into this subject using Packet Tracer, offering a hands-on, simulated exploration of networking intricacies. Stay tuned for a dynamic journey through virtual network configurations!

Unpacking The OSI Model

stungnet — Sat, 19 Aug 2023 05:40:36 +0000

Introduction

At a cursory glance, the Open Systems Interconnection (OSI) model can appear daunting with its myriad layers and intricate details. Yet, these layers ingeniously simplify what's essentially a complex dance of computer communication. By segmenting the process into seven distinct layers, the OSI model offers a clear roadmap for understanding how devices talk to each other. In this blog post, I intend to break it down so you can grasp these concepts with ease, I will illustrate this through using a post office as our guiding analogy.

Physical Layer 1 (Infrastructure)

The Physical Layer is like the foundation of a house in the world of computer networking. It's all about the actual stuff you can touch – like wires, cables, and some devices. This layer makes sure that when two computers want to 'talk', they have a set way to do it, no matter what kind of wire or connection they use. It ensures that the message gets through in a smooth and dependable manner.

Meet Sam, our dedicated OSI Post Office worker. At Layer 1, or the Physical Layer, Sam represents the hands-on, tangible side of things. Just as a mailbox, post office, and mail are physical entities in our world, the Physical Layer is all about the actual hardware and cables in networking. It's where the real, touchable parts of communication take place.

Data Link Layer 2 (Sorting)

The Data Link Layer is like a sorting room for computer data. It makes sure data goes to the right place using something called a MAC address. This address is like a name tag, ensuring the data reaches the right computer. It also uses Ethertype to tell the computer what kind of data it's getting. So, when the data arrives, the computer knows what to do with it.

In our post office story, think of the Data Link Layer as the part where Sam sorts the mail. The MAC address is like the name on the envelope, making sure each letter goes to the right home. And the Ethertype? It's how Sam knows if the mail is a simple letter, a bigger box, or a package. Just like how mail needs sorting, computers use these 'labels' to understand their data.

Network Layer 3 (Routing)

When our computer wants to send information, it needs a way to make sure it gets to the right place. This is where the Network Layer comes in. It adds special tags to our information, sort of like labels on a package in the post office.

These labels or 'tags' have details like:

Version: Is it an old or new type of label?
Time To Live (TTL): A timer that ensures our package doesn't wander around lost for too long.
Protocol: A special rule that helps the receiver understand and open our package correctly.
Source and Destination IP: The 'from' and 'to' addresses for our package.

With these tags, our information can find its way easily to its destination.

Sam, with his trusty route map, prepares each piece of mail by adding essential labels. These ensure every mail finds its right path and reaches its destination seamlessly.

Transport Layer 4 (Transport)

When data comes to the Transport Layer, it's like checking the delivery method on a package.

If it's TCP: Think of this like a careful delivery service. The system checks a special label (called the port number) to figure out which app should get the data. TCP also double-checks to make sure everything arrived in the right order and nothing is missing. It's thorough, making sure the data delivery is just right before sending it to its final spot.
If it's UDP: This is more like express delivery. It's quick and doesn't wait around. The system still checks where the data should go using that port number label, but it doesn't spend time making sure everything is perfect. It gets the data to its destination fast.

So, in a nutshell, TCP is the careful, thorough method, and UDP is the speedy one.

Sam stands at a sorting table with two bins labeled 'TCP' and 'UDP'. He's intently examining labels on each package, placing them in their respective bins.

Session Layer 5 (Connection Established)

The Session Layer is like a manager for a chat between two devices. Here's how it works:

Starting the chat (Establishment): It sets up the chat and decides if both devices will talk back-and-forth (two-way) or if one will just listen (one-way).
Keeping the chat smooth (Maintenance): While they talk, it ensures messages are sent and received clearly and that both devices are on the same page.
Ending the chat (Termination): When they're done talking, it wraps things up neatly so both devices know the conversation is over.

Sam's Delivery Steps: First, he sends a notification about the upcoming package. Next, we see him diligently biking, making sure the package stays safe. Finally, the package rests on the doorstep, signifying a completed delivery and termination of the session.

Presentation Layer 6 (Interpreter)

Once the packets arrive, the Presentation Layer steps in to make sure our computer understands the data. It changes the data into a format the system recognizes. However, not all data types need this change. This layer's main jobs are to convert the data, adjust its size, and secure or unlock it if needed.

Application Layer 7 (The Recipient)

The Application Layer is where users directly interact with the data. Think of it as a user's personal desk where they access websites, send emails, or transfer files. This layer offers the right tools and ensures the data is presented in a user-friendly manner. Some of the key tools available on this "desk" are:

HTTP/HTTPS for websites.
FTP for moving files.
SMTP for sending emails.
DNS for finding websites by name.

At the end of this journey, when someone gets their data, they might not think about the complicated process it took. They're just happy to see what they asked for.

Conclusion

Just like a post office guarantees each letter reaches its intended recipient, the OSI model directs our digital data flawlessly to its end point. By following Sam’s journey, we've unraveled the layers behind our daily online activities.

The next time you open a website or send a text, imagine Sam diligently sorting and delivering behind the scenes. Remember, every intricate system breaks down into simple steps, and grasping these basics is the pathway to expertise. Dive deep and keep exploring!

Making a basic HTTP server with Golang

stungnet — Thu, 30 Mar 2023 21:32:04 +0000

Golang is widely used for building web applications. The ease of spinning up a HTTP server is one of its key features and today I'm going to show you just how easy it is to spin one up in a few lines. Then register some paths that will show some strings let's get started!

Finished code:



package main

import (
    "fmt"      // formatting and printing values to the console.
    "log"      // logging messages to the console.
    "net/http" // Used for build HTTP servers and clients.
)

// Port we listen on.
const portNum string = ":8080"

// Handler functions.
func Home(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Homepage")
}

func Info(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Info page")
}

func main() {
    log.Println("Starting our simple http server.")

    // Registering our handler functions, and creating paths.
    http.HandleFunc("/", Home)
    http.HandleFunc("/info", Info)

    log.Println("Started on port", portNum)
    fmt.Println("To close connection CTRL+C :-)")

    // Spinning up the server.
    err := http.ListenAndServe(portNum, nil)
    if err != nil {
        log.Fatal(err)
    }
}

Required packages

For this we could really use just two packages fmt and net/http known as (http), but I enjoy having log to print certain things out in my code. If you aren't familar with these packages I've commented there use case next to them.



import (
    "fmt"      // formatting and printing values to the console.
    "log"      // logging messages to the console.
    "net/http" // Used for build HTTP servers and clients.
)

Defining handler functions

Handler functions by name will handle incoming HTTP requests. These functions will take two arguments http.ResponseWriter which we call w and r a pointer to a http.Request this is standard for declaring a handler function.

Anatomy of a handler function:



// handlerFunc handles incoming HTTP requests.
func handlerFunc(w http.ResponseWriter, r *http.Request) {
    // Message here to the response writer.
}

So what are these two arguments? when we make a request to a HTTP server, the server must process this and send back a response back to the client. Our http.ResponseWriter is used to write this response back to the client, and the http.Request object contains information about the incoming request.

So filling in our handler functions with some data now we write strings that will appear on our pages saying Homepage and Info. This is where you would pass your HTML templates if we were creating a web app. For now we just want to see our strings appear on the page.



func Home(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Homepage")
}

func Info(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Info")
}

Handling the func

Now to handle the functions we just created we use the http.HandleFunc function. this function will take two arguments, a path as a string and a handler function which we just created above.

The basic pattern of a HandleFunc is below:



// HandleFunc is used to register a handler function for a specific path on your HTTP server.
http.HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))

Now let's register some paths with the handler functions we created earlier.



// Keeping it simple we will place them in our main function.
func main(){

    http.HandleFunc("/", Home)
    http.HandleFunc("/info", Info)
    }

We've now created two paths by registering our handler functions to `/`for our homepage and `/info` for our info page. Let's now learn how we can spin up our server on our chosen port.

Can you hear me?

The last part is spinning up our server and listening. Listening in terms of network programming refers to the process of waiting for incoming network connections. Using the http.ListenAndServe function we can start a HTTP server and "listen" for incoming requests on a specified network address and port. Once a reuqest is received, it is passed to the appropriate handler function for processing.

Anatomy of a ListenAndServe:



http.ListenAndServe(port, ServeMux)

Now let's listen on port 8080 and for our ServeMux we are just using the default http.ServeMux() by using nil. ListenAndServe also returns a err, so we can error check.



// Spinning up the server.
err := http.ListenAndServe(portNum, nil)
if err != nil {
    log.Fatal(err)
}

Now run your main.go with go run main.go and visit your_ip_here:8080 or your_ip_here:8080/info in your browser to see a string printed on your new HTTP server and registered paths.

Congratulations on starting up a HTTP server, in the next post I'll show you how to add some HTML to this!

DEV Community: stungnet

Why Every Developer Should Consider the Linux & Neovim Leap

Table of Contents:

Introduction

Needing Change

Turning Point

Into the Terminal

Looking Back, Looking Forward

A Guide to Getting Started:

The Silent Power of Data Structures and Algorithms - A Developer's Guide

Introduction

What's An Algorithm? Think Gym Routine.

Data Structures? Picture This.

The Real-World Impact of DSA

Why Should You Care About DSA?

The Learning Curve – It’s Worth the Climb

Embarking on the DSA Adventure: My Recommendations So Far

Websites

YouTube

Books

From Wires to Wireless: Understanding LAN & WLAN in Your Home

Introduction

LAN (Local Area Network)

WLAN (Wireless Area Network)

Devices

Wireless Router

Router

Wireless Access Point

Switch

Conclusion - SOHO Network Diagram

From Data to Frame: The Evolution of PDUs Across the OSI Model

Introduction

Application Layer (Layer 7) - Data

Presentation Layer (Layer 6) - Data

Session Layer (Layer 5) - Data

Transport Layer 4 (Layer 4) - Segment/Datagram

Network Layer (Layer 3) - Packet

Data Link Layer (Layer 2) - Frame

Physical Layer (Layer 1) - Bits

Conclusion

Unpacking The OSI Model

Introduction

Physical Layer 1 (Infrastructure)

Data Link Layer 2 (Sorting)

Network Layer 3 (Routing)

Transport Layer 4 (Transport)

Session Layer 5 (Connection Established)

Presentation Layer 6 (Interpreter)

Application Layer 7 (The Recipient)

Conclusion

Making a basic HTTP server with Golang

Required packages

Defining handler functions

Handling the func

We've now created two paths by registering our handler functions to /for our homepage and /info for our info page. Let's now learn how we can spin up our server on our chosen port.

Can you hear me?

We've now created two paths by registering our handler functions to `/`for our homepage and `/info` for our info page. Let's now learn how we can spin up our server on our chosen port.