CyberCode Academy

CyberCode Academy

By CyberCode AcademyTechnologyEducationCourses
Download on the App Store

CyberCode Academy episodes

  • Course 4 - Learning Linux Shell Scripting | Episode 8: System Monitoring, Performance Measurement, and Log Management
    In this lesson, you’ll learn about:
    • Resource monitoring & optimization:
      • Using df and du to calculate disk usage and free space, display results in human-readable form (-H), summarize totals, exclude directories, and locate the largest files with du | sort.
      • Tracking disk I/O activity with iotop in both interactive and script modes.
      • Checking filesystem integrity using fsck, with options to simulate or automatically repair issues.
      • Measuring and tuning system power usage with powertop, generating HTML reports, and adjusting power-saving settings.
    • Performance measurement & process analysis:
      • Measuring command execution time via time, interpreting Real, User, and System times, and formatting or appending output to files.
      • Monitoring process activity with ps to track CPU and memory usage, including automated scripts to identify the top resource-consuming processes.
      • Continuously observing system output using watch, with difference highlighting (-d) between updates.
    • System status & user activity tracking:
      • Viewing logged-in users (who, w, users), uptime, and load averages.
      • Reviewing login history with last (reads /var/log/wtmp) and failed logins with lastb.
      • Analyzing session logs to calculate each user’s total activity time, login count, and ranking by usage.
    • Logging techniques & management:
      • Writing custom system log messages using logger, which integrates with syslogd and system-wide log files (boot, kernel, authentication, mail, etc.).
      • Monitoring file and directory activity with inotifywait to detect read, write, create, move, or delete events.
      • Managing log file growth using logrotate, setting parameters for size limits, rotation intervals (daily/weekly), and archived copy counts, with optional compression.
    • Security & health monitoring scripts:
      • Implementing intrusion detection by scanning /var/log/auth.log for repeated failed login attempts, extracting attacker details (user, IP, count) within a time window.
      • Automating remote health checks using SSH to gather disk usage data from multiple hosts, logging device stats and marking alerts for disks above 80% usage.
    • Key outcome:
      Gain proficiency in maintaining Linux system stability and security by actively monitoring performance, automating diagnostics, and managing logs efficiently through shell scripting.












    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    13 min
  • Course 4 - Learning Linux Shell Scripting | Episode 7: Comprehensive Network Diagnostics and Remote Host Management
    In this lesson, you’ll learn about:
    • Network connectivity & diagnostics: using ping to verify reachability and measure RTT (use -c to limit packets, check exit status), and traceroute to map hops. Techniques for discovering live hosts via parallel ping scripts or fping for fast network sweeps.
    • Secure remote access & automation (SSH): running remote commands securely, enabling compression (-C), X11 forwarding for GUI apps, and setting up passwordless login with ssh-keygen + authorized_keys for automated scripts and non-interactive sessions.
    • File transfer methods: classic FTP/lftp scripting, and secure alternatives over SSH — SCP, SFTP, and rsync (efficient delta transfers and remote backups). Best practices for automating transfers and preserving permissions.
    • Advanced network control (port forwarding & remoting): local and remote port forwarding examples, non-interactive/daemonized forwards, reverse tunnels to expose non-public machines, and mounting remote filesystems with SSHFS for local access to remote drives.
    • Network analysis & custom communication: listing open ports and connections (lsof -i, netstat -tnp), inspecting services, and building arbitrary TCP/UDP sockets with netcat (nc) for ad-hoc listeners, file transfers, or simple debugging shells.
    • Practical tips & safety: prefer encrypted channels (SSH/SFTP/rsync over SSH), restrict forwarded ports and keys to minimal scope, monitor open ports regularly, and test automation on controlled hosts before production use.






























    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    14 min
  • Course 4 - Learning Linux Shell Scripting | Episode 6: The Backup Plan
    In this lesson, you’ll learn about: The Backup Plan — Data Management, Archiving, and Backup Automation
    This section provides a deep dive into data management strategies, focusing on archiving, compression, specialized file systems, and automated backup solutions. It builds upon the previous lesson, where web interaction through shell scripting was introduced. 🗃️ Archiving Fundamentals • tar (Tape Archive):
    • Create and manage archive files (“tarballs”).
    • Perform operations like create, list, extract, append (-R), update (-u), and concatenate (-A).
    • Use verbose output (-v), wildcards for file selection, and exclude unwanted directories (e.g., .git).
    • cpio (Copy In/Out):
    • Understand this archive format, similar to tar, used mainly in RPM packages and Linux kernel init RAM FS.
    • Though less common, it remains an important legacy tool for low-level archiving.
    📦 Data Compression Techniques • gzip:
    • Compress single files efficiently.
    • Control output to standard output (-c) and set compression levels (1–9, or --fast / --best).
    • Use zcat to read compressed files without extraction.
    • bzip2:
    • Achieve higher compression ratios than gzip, though with slower processing.
    • lzma:
    • Offers even stronger compression performance, ideal for minimizing storage space.
    • zip:
    • Combines archiving and compression in one step, widely supported across platforms.
    • pbzip2:
    • A parallelized version of bzip2 using multiple CPU cores (Pthreads).
    • Greatly speeds up compression but requires tar for handling multiple files.
    💾 Specialized Data and System Management • SquashFS (Squash File System):
    • Create read-only, compressed file systems commonly used in Linux Live CDs/USBs.
    • Access compressed data on-demand through loopback mounting, avoiding full extraction.
    🧠 Advanced Backup Strategies • rsync (Remote Sync):
    • Synchronize and back up files efficiently by transferring only changes.
    • Support for SSH, compression (-z), and cron scheduling for automation.
    • Perfect for maintaining remote or incremental backups.
    • git (Version-Control Backup):
    • Apply Git’s versioning to regular files for incremental and differential backups.
    • Track changes, mark snapshots, and restore previous versions.
    • Not ideal for large binary-only datasets.
    • FS Archiver:
    • Create compressed disk images of entire file systems, including metadata.
    • Supports modern file systems like ext4, simplifying full restoration and migration.
    In summary:
    This section equips you with a complete toolkit for data protection — from simple file compression (gzip, zip) and archiving (tar), to powerful synchronization (rsync), version-based tracking (git), and full disk imaging (FS Archiver). Together, these tools form the foundation for a reliable, automated backup plan that ensures data integrity and recovery across systems.











    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    17 min
  • Course 4 - Learning Linux Shell Scripting | Episode 5: Shell Scripting for Web Automation, Data Retrieval, and Parsing
    In this lesson, you’ll learn about: Tangled Web — Automating Web Interaction with Shell Scripting
    This section focuses on how shell scripting and command-line tools can be used to interact with and automate web-related tasks. It explains how to retrieve, parse, send, and monitor web data using the HTTP protocol through utilities like wget, curl, and links. 🌐 Core Command-Line Utilities for Web Interaction • wget (Web Download Utility):
    • Download files and web pages with options to resume interrupted downloads (-C) and set retry limits (-t).
    • Control bandwidth usage (--limit-rate) and quotas (--quota, -Q).
    • Perform full website mirroring (--mirror, -L, -R).
    • Support authentication via --user, --password, or secure password prompts (--ask-password).
    • links (Command-Line Web Browser):
    • Convert web pages into plain text by stripping HTML tags.
    • Use the -dump option to display page content and list all hyperlinks under a “References” section.
    • curl (Powerful Transfer Utility):
    • Handle HTTP, HTTPS, and FTP data transfers.
    • Execute POST requests, manage cookies, and use authentication (-u).
    • Save files using remote (-O) or custom (-o) filenames.
    • Resume downloads (-C), set referrers (--referrer), and customize user agents (-A).
    • Retrieve only HTTP headers (-I, --head) to verify content without downloading full files.
    ⚙️ Data Processing and Automation Scripts • Parsing Website Data:
    • Extract and reformat specific information from web pages by combining links -no-list, grep, and sed.
    • Image Crawler and Downloader:
    • Write scripts to extract image URLs (both absolute and relative) and automatically download them with curl.
    • Web Photo Album Generator:
    • Automate photo album creation using a for loop and the ImageMagick convert utility to create thumbnails (e.g., 100 px).
    • Generate an index.html file containing image tags and layout automatically.
    • Define Utility (Dictionary Script):
    • Use a dictionary API (e.g., Merriam-Webster) with curl to fetch data.
    • Apply grep, sed, and nl to extract and format word definitions.
    🛠️ Website Maintenance and Interaction • Finding Broken Links:
    • Collect all URLs recursively using links -traversal and check their status codes with curl -I to find dead links.
    • Tracking Changes:
    • Monitor websites for content updates by fetching new and old versions (recent.html, last.html) and comparing them with diff.
    • Posting Data to Web Pages:
    • Automate form submissions (like logins) using POST requests.
    • Send variable=value pairs with curl -d or wget --post-data and process the response.
    In summary:
    This section teaches how to automate web-related tasks such as downloading, parsing, monitoring, and submitting data directly from the command line—eliminating the need for manual browsing.
    Analogy:
    Learning this module is like programming a set of digital “bots” — each tool (curl, wget, links) acts as a specialized agent that collects, filters, and interacts with online data to create fully automated web workflows.











    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    15 min
  • Course 4 - Learning Linux Shell Scripting | Episode 4: Shell Text Processing: Mastering Utilities and Regular Expressions
    In this lesson, you’ll learn about: 🧠 Core Concept: Text Processing in Unix/Linux
    This section, titled “Texting and Driving,” focuses on the art and science of text manipulation—a cornerstone of shell scripting. You’ll explore powerful utilities like grep, sed, awk (or ORC), and cut, all built around Regular Expressions (REs)—a miniature programming language for pattern matching across characters, words, lines, columns, and rows. 🔍 Core Utilities and Functions
    • Grep (Searching and Mining): Search for text patterns within files using features like:
    • -E for extended regex, -o to show only matches, -v to invert results, -c to count, -R for recursive searches, and -i for case-insensitive matching.
    • Use multiple patterns and show context with -A, -B, and -C.
    • Sed (Stream Editor/Text Replacement): Perform inline editing and transformation using regular expressions. Learn to:
    • Replace globally (/g), save edits in place (-i), use back-references (\1, \2), remove blank lines, and chain multiple expressions together.
    • AWK/ORC (Advanced Processing): Handle data streams and structured text (columns and rows).
    • Use BEGIN, pattern/action, and END blocks.
    • Employ variables like NR (line number), NF (number of fields), $1...$NF (fields).
    • Pass variables with -v, filter with patterns, and apply string/array functions for rich data processing.
    • Cut (Column-wise Extraction): Extract specific columns or characters from text.
    • Define custom delimiters (-d), select multiple fields, or slice by character (-c) or byte (-b) position.
    ⚙️ Applied Text Processing Tasks
    • Word Frequency Analysis: Combine grep and awk to count and rank words in a file.
    • JavaScript Compression/Decompression: Automate whitespace and comment removal (minification) and reverse it for readability.
    • File Merging and Ordering: Merge files side-by-side with paste, or reverse file content using tac or awk.
    • Data Extraction and Slicing: Print specific words, columns, or text blocks based on line ranges or patterns.
    • Parsing and Filtering: Use regex to extract data like emails or URLs and remove sentences containing unwanted keywords.
    • Batch Operations: Chain find, xargs, and sed to replace text patterns across entire directories.
    • Bash Parameter Expansion: Apply text replacement and substring slicing directly within shell variables. 💡 Analogy for Understanding
    Think of this section as receiving a master chef’s knife set—grep, sed, awk, and cut—alongside a recipe book of regular expressions. You’ll first learn how to sharpen your tools (master regex), then practice fine slicing, dicing, and blending (searching, replacing, parsing, slicing) to craft any data “dish” with surgical precision. This lesson equips you with professional-grade text processing skills—transforming raw, unstructured data into clean, organized information ready for automation or analysis.








    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    18 min
  • Course 4 - Learning Linux Shell Scripting | Episode 3: Comprehensive Unix File and Directory Management Utilities
    In this lesson, you’ll learn about: 📁 File Creation, Size, and Storage Management
    • Generating Files of Any Size: Learn to use the low-level dd command to create files of specific sizes using block size (BS) and count parameters—ideal for test data or loopback file systems.
    • Loopback File Systems: Understand how to create virtual disk images that can be mounted like physical drives using mount -o loop, and how to partition them with tools like fdisk.
    • Generating Blank Files in Bulk: Use touch to create empty files or modify timestamps, with examples of bulk file creation using shell patterns. ⚖️ Comparison, Difference, and Duplicate Handling
    • Intersection and Set Difference: Apply the comm command to find lines common to or unique between two sorted files.
    • Finding and Deleting Duplicates: Build scripts that detect duplicates by first comparing file sizes, then confirming identical content via checksums (md5sum), and finally deleting redundant copies.
    • File Differencing and Patching: Use diff -u to create readable patch files and apply or revert changes using patch and patch -R. 🔒 File Permissions and Security Attributes
    • Permissions and Ownership: Manage access rights using chmod (symbolic or numeric), and change ownership with chown.
    • Special Permissions: Understand Set UID, Set GID, and the Sticky Bit (+t), especially in shared directories like /tmp.
    • Immutability: Protect files from modification or deletion using chattr +i, even against superuser changes. 📊 File Information, Types, and Statistics
    • Symbolic Links: Create, find, and inspect symbolic links using ln, find, and readlink.
    • File Type Enumeration: Use the file command to detect file types and script recursive directory scans to count and categorize them.
    • Counting Data: Employ wc to count lines, words, characters, and determine the longest line length with -L. 📜 Viewing and Navigation Utilities
    • Viewing File Portions: Display specific sections of files with head and tail, and monitor live log updates using tail -f.
    • Directory Listing Alternatives: Filter output from ls -F or use find -type d to list only directories.
    • Fast Navigation: Use pushd and popd to manage a directory stack for quick path switching.
    • Visualizing Directory Structures: Generate a tree-style directory overview using the tree command, including pattern filtering and HTML output. This lesson provides practical mastery of Unix’s “everything is a file” philosophy—equipping you to create, compare, protect, and navigate files and directories with precision and efficiency.








    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    15 min
  • Course 4 - Learning Linux Shell Scripting | Episode 2: Essential Unix/Linux Command Line Utilities and Advanced Techniques
    In this lesson, you’ll learn about:
    • Text & File Management Basics
      • Using cat to read, display, and concatenate files, including combining stdin and file input.
      • Cleaning up file output (removing blank lines, showing tabs as ^I).
      • Splitting files with split (by size or line count) and csplit (by context or text match).
      • Creating temporary files/directories using mktemp, stored securely in /tmp.
      • Manipulating filenames via shell operators (%, %%, #, ##) to extract extensions or URL parts.
      • Performing bulk renaming/moving with find, mv, and rename using regex or substitution (e.g., replacing spaces).
    • Powerful Processing & Automation Tools
      • find: Recursive file search by name, regex, depth (-maxdepth, -mindepth), type, timestamps (-mtime, -ctime, -newer), size, and permissions, with pruning and efficiency optimizations.
      • xargs: Converts stdin into command arguments, combines with find -print0 and xargs -0 to handle filenames with spaces.
      • tr: Translates or deletes characters (e.g., case conversion, newline replacements, ROT13).
      • sort & uniq: Sort data numerically, alphabetically, or by key; extract or detect duplicates (requires sorted input).
    • Data Integrity & Security Utilities
      • Generating checksums using md5sum and sha1sum for file verification.
      • Recursive checksum verification using tools like md5deep.
      • Encrypting/decrypting files with crypt and gpg.
      • Base64 encoding/decoding for ASCII-safe binary data conversion.
      • Creating password hashes using openssl (e.g., salted shadow-style hashes).
    • Terminal Environment & Workflow Optimization
      • Recording command sessions using script and replaying with scriptreplay for tutorials or demos.
      • Automating input via stdin redirection (echo -e "input\n" | command) and using the expect utility for interactive prompts.
      • Spell-checking text using aspell or the system dictionary (/usr/share/dict/words).
      • Leveraging parallelism with background jobs (&) and wait to execute multiple tasks (like md5sum) concurrently.
    • Core Objective
      • Mastering the Unix/Linux command line as an art, combining tools (like find + xargs + grep) into powerful pipelines to solve complex automation and processing challenges efficiently.


    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    14 min
  • Course 4 - Learning Linux Shell Scripting | Episode 1: Essential: Utilities, Variables, I/O, and Program Flow
    In this lesson, you’ll learn about:
    • Shell I/O & printing: echo (flags like -n), printf for formatted output, colored text via escape sequences, and printing alignment/rounding.
    • File descriptors & redirection: stdin/stdout/stderr (0/1/2), >, >>, 2>, &>, piping |, tee, /dev/null, and creating custom FDs with exec.
    • Reading input & command output: read (including fixed-char reads), capturing command output via $(...) or backticks, and assigning pipeline results to variables.
    • Variables & environment: scalar assignment, environment variables (env), key system vars (PATH, UID, PS1), checking string length, and prepending paths.
    • Arrays: indexed arrays and associative arrays (Bash ≥4), listing elements/indexes, and getting array length.
    • Arithmetic: integer math with let, (( ... )), [...]; floating-point and advanced math with bc, and base conversions.
    • Functions & arguments: define/invoke functions, access $1, $@, and read exit status/return codes.
    • Control flow: if / else / nested conditionals, numeric and string comparisons ([[ ... ]]), logical operators && / ||, and the test command.
    • Loops & iterators: for (including C-style and sequence generation), while, and until (including infinite loops).
    • IFS & field handling: using IFS to parse CSV or colon-delimited data (e.g., /etc/passwd) safely.
    • Conditional execution & retries: loop until success patterns, use : for no-op, and sleep for delays between retries.
    • Aliases & safety: create/remove aliases (alias / unalias), persist to ~/.bashrc, and escape to avoid malicious alias interference.
    • Terminal control: tput for cursor, colors, and styling; stty for terminal modes (e.g., disable echo for password input).
    • Date/time utilities: format/parse dates, convert to/from Epoch, and compute time differences.
    • Debugging techniques: run scripts with -x, use set -x / set +x for scoped tracing, and add custom debug output (e.g., _debug checks).
    • Best practices: validate inputs, limit side effects, handle errors via exit codes, use strict quoting, and test scripts in safe environments.


    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    18 min
  • Course 3 - Mastering Nuclei for Bug Bounty | Episode 8: Nuclei File-Based Templates: Implementing Content Matching and Secret Extraction
    In this lesson, you’ll learn about:
    • Nuclei file-based templates — purpose: extending Nuclei beyond HTTP to scan local files and codebases for sensitive content (hard‑coded secrets, API keys, credentials, tokens).
    • File block basics: replace requests with a file: block in the template to target files instead of sending network requests.
    • Targeting options:
      • extensions: specify file types to scan (e.g., txt, py).
      • - or hyphen all / match all patterns to search across all extensions.
      • max-size: limit (bytes) to skip very large files (e.g., 1024) and save resources.
      • no-recursive: disable recursive directory traversal when needed.
    • Matchers for file content:
      • Word matchers: find exact whole-word occurrences.
      • Regex matchers: use regexes for flexible/patterned matching (e.g., API key formats).
      • Combine part/context and status-like conditions to reduce false positives.
    • Extractors — pulling secrets:
      • Define extractors (word or regex) to capture the actual secret/token when a matcher hits.
      • Use extractors to output matched values (e.g., the API key string) for triage.
    • Practical workflow:
      • Build the file template with id/info/file/matchers/extractors.
      • Validate YAML (YAML Lint) and test locally on a safe directory.
      • Run Nuclei pointed at a path or file list and review extracted results.
    • Use cases: auditing repos for hard‑coded credentials, scanning downloaded code archives, searching config folders for secrets, or reviewing build artifacts before release.
    • Safety & operational tips:
      • Only scan files and code you’re authorized to analyze.
      • Set reasonable max-size and avoid scanning entire OS trees unnecessarily.
      • Use precise regexes to reduce false positives and noisy output.
      • Securely handle and store any extracted secrets (treat as sensitive data).
    • Core takeaway: Nuclei file templates are a powerful, scriptable way to automate discovery and extraction of sensitive content in local files — combine careful matcher design, extractors, and safety practices for effective, responsible audits.












    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    9 min
  • Course 3 - Mastering Nuclei for Bug Bounty | Episode 7: Exploiting Business Logic Flaws and Achieving Multiple Redemptions
    In this lesson, you’ll learn about:
    • Race conditions — definition & impact: concurrency bugs that occur when multiple requests/threads read/write the same resource simultaneously; often business‑logic flaws (e.g., redeeming a single‑use coupon multiple times) that can cause direct financial loss.
    • Common targets & scenarios: single‑use tokens, gift cards, coupon redemptions, inventory decrements, account balance updates, and other stateful operations that must be atomic.
    • Detection approaches:
      • Identify endpoints that perform state changes (POST/PUT) with weak server‑side atomicity.
      • Look for operations lacking proper locking, transactional guarantees, or server‑side checks.
      • Reproduce by sending many near‑simultaneous requests and observing duplicate successful responses.
    • Nuclei race‑testing (template features):
      • Use method: post (or appropriate method) and set the request body with the token/coupon.
      • Enable concurrency testing with race: true and control parallelism via race-count: (e.g., race-count: 10).
      • Match on success by expecting multiple status: 200 responses or other success indicators to confirm the race exploit.
    • Alternative tooling: Turbo Intruder (Burp) is commonly used for high‑precision, high‑concurrency tests when fine control over timing is required.
    • Practical workflow:
      • Reconstruct the raw request (proxy via Burp).
      • Build and validate a Nuclei template (or Turbo script).
      • Run against a safe/staging target with controlled race‑count.
      • Inspect timestamps/responses to confirm simultaneous requests and duplicated success.
    • Real‑world example & rewards: many real bounties (e.g., HackerOne reports) stem from race exploits that allow multiple redemptions; successful findings can yield high rewards because they directly translate to monetary impact.
    • Mitigations & secure design:
      • Enforce server‑side atomic operations (database transactions, row‑level locking).
      • Use optimistic locking with version checks or strong uniqueness constraints.
      • Implement server‑side one‑time token invalidation that’s atomic.
      • Rate‑limit and monitor suspicious concurrent attempts on critical endpoints.
    • Ethics & safety: only test race conditions on systems you are authorized to test (staging or explicitly in‑scope targets), because aggressive concurrent tests can disrupt services.


    You can listen and download our episodes for free on more than 10 different platforms:
    https://linktr.ee/cybercode_academy

    Get the books of the CyberCode Academy podcast:
    📚 The book series: 416 lessons, 12 books, hundreds of original diagrams: security, networking and programming.
    https://cybercodeacademy.gumroad.com/
    10 min

About CyberCode Academy

From the publisher's feed

Welcome to CyberCode Academy — your audio classroom for Programming and Cybersecurity.
🎧 Each course is divided into a series of short, focused episodes that take you from beginner to…