created pages:

-Developing a Desktop Environment in Go
- What is GNS3?

Gemfile

@@ -34,4 +34,8 @@ gem "http_parser.rb", "~> 0.6.0", :platforms => [:jruby]
 
 gem "jekyll-admin"
 gem "jekyll-theme-chirpy"
-gem 'jekyll-redirect-from'
+gem 'jekyll-redirect-from'
+gem 'csv'
+gem 'sass-embedded'
+gem "rackup"
+gem "sinatra", ">= 3", "< 4"

_posts/2024-12-15-developing-a-desktop-environment-in-go.md

@@ -0,0 +1,204 @@
+---
+title: Developing a Desktop Environment in Go
+layout: post
+comments: false
+toc: true
+categories:
+- Linux
+- Programming
+- Go
+tags:
+- linux
+- programming
+- go
+---
+
+Desktop environments are an essential part of a graphical user interface (GUI) in operating systems, providing users with tools like window management, task switching, and application launching. While many desktop environments are written in languages like C or C++, Go's simplicity and performance make it a compelling choice for building lightweight and efficient systems.
+
+In this article, we'll explore how to develop a basic desktop environment using Go, leveraging the xgb and xgbutil libraries. We'll walk through examples and concepts like connecting to the X server, handling windows, and drawing simple UI elements.
+Prerequisites
+
+Before diving in, make sure you have the following:
+
+    A Linux system with an X server running.
+    Go installed (1.20 or later recommended).
+    The xgb and xgbutil packages installed: 
+
+go get -u github.com/BurntSushi/xgb github.com/BurntSushi/xgbutils
+
+**Step 1: Connecting to the X Server**
+
+The first step in interacting with the X server is to establish a connection. The xgb library provides low-level access to X, and xgbutil adds higher-level utilities to make development easier.
+
+```go
+package main
+
+import (
+
+	"log"
+	"github.com/BurntSushi/xgb"
+	"github.com/BurntSushi/xgb/xproto"
+
+)
+
+func main() {
+	// Connect to the X server
+	conn, err := xgb.NewConn()
+	if err != nil {
+		log.Fatalf("Failed to connect to X server: %v", err)
+	}
+
+	defer conn.Close()
+
+	// Get the root window
+	setup := xproto.Setup(conn)
+	root := setup.DefaultScreen(conn).Root
+	log.Printf("Connected to X server. Root window ID: %d\n", root)
+} 
+```
+
+**Step 2: Handling Window Events**
+
+Desktop environments need to manage windows—create, move, resize, and close them. Here's how to listen for and process window-related events:
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/BurntSushi/xgb"
+	"github.com/BurntSushi/xgb/xproto"
+)
+
+func main() {
+	conn, err := xgb.NewConn()
+	if err != nil {
+		log.Fatalf("Failed to connect to X server: %v", err)
+	}
+	defer conn.Close()
+
+	// Get the root window
+	setup := xproto.Setup(conn)
+	root := setup.DefaultScreen(conn).Root
+
+	// Subscribe to events
+	mask := xproto.EventMaskSubstructureRedirect | xproto.EventMaskSubstructureNotify
+	if err := xproto.ChangeWindowAttributesChecked(conn, root, xproto.CwEventMask, []uint32{uint32(mask)}).Check(); err != nil {
+		log.Fatalf("Failed to subscribe to events: %v", err)
+	}
+
+	log.Println("Listening for window events...")
+
+	// Event loop
+	for {
+		event, err := conn.WaitForEvent()
+		if err != nil {
+			log.Fatalf("Error waiting for event: %v", err)
+		}
+
+		switch e := event.(type) {
+		case xproto.MapRequestEvent:
+			log.Printf("Map request for window ID: %d\n", e.Window)
+			// Map the window to make it visible
+			xproto.MapWindow(conn, e.Window)
+		default:
+			log.Printf("Unhandled event: %T\n", e)
+		}
+	}
+} 
+```
+
+This code listens for MapRequest events, which occur when a window requests to be displayed. The window is then made visible using xproto.MapWindow.
+Step 3: Creating a Basic Window Manager
+
+With xgbutil, you can simplify window management by using higher-level abstractions. Here’s an example of creating a basic window manager with xgbutil:
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/BurntSushi/xgbutil"
+	"github.com/BurntSushi/xgbutil/xevent"
+	"github.com/BurntSushi/xgbutil/xwindow"
+)
+
+func main() {
+	// Initialize xgbutil
+	X, err := xgbutil.NewConn()
+	if err != nil {
+		log.Fatalf("Failed to initialize X connection: %v", err)
+	}
+
+	// Get the root window
+	root := X.RootWin()
+
+	// Listen for new window events
+	xwindow.New(X, root).Listen(xevent.MapRequest, xevent.ConfigureRequest)
+
+	log.Println("Window manager running...")
+
+	// Handle MapRequest (when a new window is opened)
+	xevent.MapRequestFun(func(X *xgbutil.XUtil, e xevent.MapRequestEvent) {
+		log.Printf("New window mapped: %d\n", e.Window)
+		xwindow.New(X, e.Window).Map()
+	}).Connect(X, root)
+
+	// Main event loop
+	xevent.Main(X)
+} 
+```
+
+This code sets up a simple event loop to map new windows and respond to MapRequest events.
+
+**Step 4: Drawing UI Elements**
+
+To draw UI components like taskbars or background colors, you can use the X server’s CreateWindow function:
+
+```go
+package main
+
+import (
+	"log"
+
+	"github.com/BurntSushi/xgb"
+	"github.com/BurntSushi/xgb/xproto"
+)
+
+func main() {
+	conn, err := xgb.NewConn()
+	if err != nil {
+		log.Fatalf("Failed to connect to X server: %v", err)
+	}
+	defer conn.Close()
+
+	// Get root window
+	setup := xproto.Setup(conn)
+	screen := setup.DefaultScreen(conn)
+	root := screen.Root
+
+	// Create a new window
+	win, _ := xproto.NewWindowId(conn)
+	xproto.CreateWindow(conn, screen.RootDepth, win, root, 0, 0, 800, 50, 0,
+		xproto.WindowClassInputOutput, screen.RootVisual,
+		xproto.CwBackPixel|xproto.CwEventMask,
+		[]uint32{screen.WhitePixel, xproto.EventMaskExposure})
+
+	// Map (show) the window
+	xproto.MapWindow(conn, win)
+
+	log.Println("Taskbar created!")
+	select {} // Keep the program running
+} 
+```
+
+This example creates a basic taskbar window at the top of the screen.
+Conclusion
+
+Developing a desktop environment in Go with xgb and xgbutil provides low-level control and flexibility over the X server, making it suitable for lightweight and custom environments. While this guide covers basic functionality, a full-featured desktop environment would involve more advanced features like window decorations, input handling, and inter-process communication.
+
+For a more complete implementation, check out the [Onix Desktop Environment](https://gitlab.com/onix-os/applications/odesk), which is a project built with similar concepts.
+
+Happy coding!

_posts/2024-12-15-what-is-gns3.md

@@ -0,0 +1,43 @@
+---
+title: What is GNS3?
+layout: post
+comments: false
+toc: true
+categories:
+- Linux
+- Programming
+- Go
+tags:
+- linux
+- programming
+- go
+---
+
+GNS3 (Graphical Network Simulator-3) is a powerful open-source network simulation platform used by network engineers, students, and IT professionals to design, build, and test network topologies in a virtual environment. It supports various devices like routers, switches, and firewalls, making it a versatile tool for both learning and real-world network troubleshooting.
+Key Features
+
+    Multi-vendor Support: Emulates devices from vendors like Cisco, Juniper, and Fortinet.
+    Scalability: Simulates small to large networks with high performance.
+    Integration: Works seamlessly with real network devices and virtualization platforms (e.g., VMware, VirtualBox).
+
+Why Use GNS3?
+
+    Learning: Perfect for CCNA, CCNP, or CCIE certification studies.
+    Testing: Simulate network changes before applying them in production.
+    Cost-effective: Avoid the need for expensive physical hardware.
+
+How to Get Started
+
+    Download GNS3: Visit the [official website](https://gns3.com/) to download and install.
+    Documentation: Check the [GNS3 documentation](https://docs.gns3.com/docs/) for setup and troubleshooting guides.
+    Community: Join the [GNS3 Community](https://gns3.com/community/featured) to connect with other users.
+
+Alternatives
+
+If GNS3 isn’t the perfect fit for your needs, consider alternatives like:
+
+    Cisco Packet Tracer (ideal for beginners)
+    EVE-NG (advanced users)
+    NetSim (commercial option)
+
+Start building your virtual lab today with GNS3 and take your networking skills to the next level!