• OSINT ( Google operators list )
    • Burp Suite Cheat sheet
    • John the ripper Cheat Sheet
    • Metasploit cheat sheet
    • Nmap cheat sheet
    • Snort cheat sheet
    • SQL Injection cheat sheet
    • SSL/TLS Vulnerability Cheat Sheet
    • TCPdump Cheatsheet
    • Wireshark Cheat sheet
    • A beginner's guide to the Elixir programming language
    • A Deep Dive into Pheonix Framework
    • Build a CLI Todo List using Elixir
    • Client-server communication with GenServer
    • Concurrency in Elixir with OTP
    • Create A Simple Web Server using Elixir
    • File Word Counter
    • Simple state management with agents
    • Testing in Elixir with ExUnit
    • Using Docker and Elixir
    • Using Ecto for Database Interactions
    • A Getting Started Guide With Elm
    • Core Concepts in Elm
    • Create a Simple Registration Form
    • Error Handling in Elm
    • huCreating a Random Quotes App in Elm
    • Package Manager in Elm
    • The Elm Architecture
    • Working with HTTP Requests
    • A Getting Started Guide with Erlang
    • Binaries in Erlang Programming Language
    • Concurrency and Process Management in Erlang
    • Connecting to SQL Databases Using Erlang's ODBC Library
    • Distributed Programming
    • Macros in Erlang Programming Language
    • Modules in Erlang Programming Language
    • Pattern Matching in Erlang
    • Practical Applications and Best Practices
    • Understanding Erlang's OTP Framework
    • Web Programming in Erlang
    • Build a Text Summarizer using MERN
    • Building a Note-Taking Application with Rust and React
    • Building an Expense Tracker with Rust and React
    • Creating a Simple Chat Application using Go and React
    • Creating a Simple Chat Application using Go and React
    • Job Description Summarizer with Streamlit and OpenAI
    • Progress Tracker using React and Local Storage
    • Simple Password Validator using React + Go
    • Task Manager using Django and React
    • Advanced Error Handling in Go
    • Building Microservices with Go
    • Efficient Go Programming
    • Exploring Advanced Features of Go
    • Exploring Channels in Go
    • Exploring Functions in Go
    • Getting Started with Go
    • Master the Basics of Go
    • Mastering Concurrency in Go with Goroutines
    • Mastering Testing in Go
    • Understanding Structs and Interfaces in Go
    • Using Databases in Go
    • Working with Collections in Go
    • Building a Real-World Haskell Application
    • Diving Deeper into Haskell Functions
    • Effective Error Handling in Haskell
    • Effective Testing and Debugging in Haskell
    • Exploring Advanced Data Types in Haskell
    • Exploring Functional Design Patterns in Haskell
    • Exploring Haskell Syntax and Basic Concepts
    • Harnessing Concurrency and Parallelism in Haskell
    • Interfacing Databases with Haskell
    • Introduction to Haskell
    • Mastering Haskell’s Module System for Efficient Code Organization
    • Mastering List Operations in Haskell
    • Monad Magic in Haskell
    • Understanding Type Classes and Polymorphism in Haskell
    • A Getting started guide with HTMX
    • AJAX in HTMX
    • Caching
    • htmx usage with Django
    • Other hx-Attributes
    • Security in HTMX
    • Web Security Basics using HTMX
    • Web Socket and SSE
    • A simple Huff Program to Determine Even Number
    • An Introduction to Huff
    • Creating a Huff Contract for Signature Verification
    • Creating a Token With Huff
    • Hello World using Huff
    • Reversing Calldata with Huff: A Step-by-Step Tutorial
    • Some Advanced Features With Huff
    • Testing and Deploying Huff Contracts
    • Understanding Huff Macros
    • A Getting Started Guide with Julia
    • Asynchronous Programming with Julia
    • Basic Calculator with Julia
    • Learn About Advanced Features with Julia
    • Modules in Julia
    • Multi-Thread Programming with Julia
    • Object Oriented Programming with Julia
    • Scientific Computing with Julia
    • An Introduction to keras
    • Deploying Keras Models
    • Model evaludation and prediction in keras(Advanced)
    • Model Tuning and Optimization Techniques in Keras
    • Modules in keras
    • Training models on arbitrary data sources
    • Writing cross-framework custom components
    • A Getting Started Guide to Mojo
    • Data Types, Variables, and Operators in Mojo
    • Functions in Mojo
    • Interoperability with Python
    • Modules and Packages in Mojo
    • Object-Oriented Programming (OOP) Concepts in Mojo
    • An Introduction to Nim
    • Basic data types in Nim
    • Channels in Nim
    • Concurrency in Nim
    • Containers and Procedures in Nim
    • Control flow in Nim
    • Modules in Nim
    • Nim Macros: A Comprehensive Tutorial
    • Object-Oriented Programming in Nim
    • Parallelism in Nim
    • Advanced Array Manipulation with NumPy
    • An Introduction to NumPy
    • Applications and Advanced Numpy Concepts
    • Indexing and Slicing In Numpy
    • Linear Algebra with NumPy
    • NumPy Broadcasting
    • NumPy Operations
    • Random Number Generation and Sampling with NumPy
    • Advanced Concepts in OCaml
    • An Introduction to OCaml: A Versatile Programming Language
    • Core Concepts in OCaml
    • Error Handling in OCaml
    • File Manipulation in OCaml
    • Handling Command-Line Arguments in OCaml
    • Working with the Garbage Collector in OCaml
    • Advanced Data Aggregation and Grouping in Pandas
    • An Introduction to Pandas
    • Extending Pandas with PyArrow: Enhanced Functionality and Performance
    • How to Clean Data using Pandas
    • Indexing and Selection of Data in Pandas
    • Introduction to Data Structures in Pandas
    • Time Series Analysis with Pandas
    • Viewing and Understanding Dataframes
    • Windowing Operations in Pandas
    • Working with Missing Data in Pandas
    • Comprehensive Guide to Testing in Python: Unit Tests and Mocking Techniques
    • Demystifying Python Decorators: Enhancing Functionality with Decorators
    • Effective Error Handling in Python: Try-Except Blocks and Finally Clause
    • Efficient File Handling in Python: Reading, Writing, and Path Management
    • Essentials of Python for Machine Learning: Libraries, Concepts, and Model Building
    • Exploring Advanced Data Structures in Python: Collections and Priority Queues
    • Exploring Python Operators: Arithmetic, Comparison, and Logical Operations
    • Introduction to Python
    • Mastering Concurrency and Parallelism in Python: Threading, Multiprocessing, and Asyncio
    • Mastering Control Structures in Python: If Statements, Loops, and More
    • Mastering Dictionaries and Sets in Python: Comprehensive Guide to Data Handling
    • Mastering Object-Oriented Programming in Python: Classes, Inheritance, and Polymorphism
    • Mastering String Manipulation in Python: Operations, Methods, and Formatting
    • Mastering the Basics: Python Syntax, Indentation, and Comments
    • Python Modules and Packages: Importing Essentials and Exploring Standard Libraries
    • Understanding Functions in Python: Definitions, Parameters, Returns, and Scope
    • Understanding Iterators and Generators in Python: Leveraging Yield for Efficient Code
    • Understanding Python Variables and Data Types: From Basics to Type Conversion
    • Working with Lists and Tuples in Python: Creation, Access, and More
    • An Introduction to PyTorch
    • Deep Dive into PyTorch: Autograd and Neural Networks
    • Deep Dive into Tensors
    • Deploying PyTorch in Python via a REST API with Flask
    • Model Training and Evaluation
    • PyTorch: Data Loading and Preprocessing
    • Transferr Learning in Pytorch
    • Writing a training loop from scratch in PyTorch
    • Advanced Enums and Pattern Matching in Rust
    • Basic Concepts in Rust
    • Building a Robust CLI Tool with Rust
    • Control Flow in Rust
    • Control Flow in Rust
    • Effective Testing Strategies in Rust
    • Exploring Advanced Types in Rust: Structs and Enums
    • Getting Started with Rust
    • Integrating Rust with Other Languages: FFI and Safe Abstractions
    • Leveraging the Power of Slices in Rust
    • Mastering Collections in Rust: Vectors, HashMaps, and HashSets
    • Mastering Concurrency in Rust
    • Mastering Generic Types and Traits in Rust
    • Mastering Lifetime Management in Rust
    • Mastering Macros in Rust
    • Mastering References and Borrowing in Rust
    • Mastering Structs in Rust: Definition, Methods, and Usage
    • Robust Error Handling in Rust: Using Result and Option
    • Smart Pointers in Rust
    • Structuring Rust Projects: Modules and Crates Explained
    • Understanding and Using Unsafe Rust
    • Unlocking Asynchronous Programming in Rust
    • Your First Rust Program
    • Advanced Concepts in Scala
    • An Introduction to Scala
    • Exploring Arrays in Scala
    • Functional Programming in Scala
    • Future and Promises in Scala
    • Object-Oriented Programming in Scala
    • String Interpolation in Scala
    • Understanding Maps in Scala
    • An Introduction To Solidity
    • Build A Crowdfunding Contract with Solidity and ERC20 Tokens
    • Build a Remote Purchase Contract Using Solidity
    • Build a Voting Contract Using Solidity
    • Effective error handling in Solidity
    • Essential Gas Optimization Techniques in Solidity
    • How to Send and Receive Ether in Solidity
    • Learn About Reentracny Attacks and how to Prevent them
    • Learn How To Write Unit Tests In Solidity
    • Price Oracle Using Chainlink and Solidity
    • Solidity and ERC20 Tokens
    • Understandin Application Binary Interface (ABI) in Solidity
    • An Introduction to System Design
    • API Architecture: Design Best Practices for REST APIs
    • Database Sharding: Concepts and Examples
    • Deep Dive into WebSockets
    • NoSQL vs. SQL Databases: A Comprehensive Overview
    • The Difference Between TCP and UDP
    • The Domain Name System
    • Understanding a Reverse Proxy??
    • Understanding ACID Transactions in Database Systems
    • Understanding the Difference Between Throughput and Latency in Network Performance
    • Using Database Indexes for Improved Performance
    • What Is an API Gateway?
    • What is Caching?
    • What is Load Balancing?
    • A Getting Started guide to Technical Architecture: Principles and Best Practices
    • Choosing the Right Technology Stack for Your Project
    • Ensuring Security in Your Technical Architecture
    • Event-Driven Architecture
    • Implementing CI/CD Pipelines for Seamless Deployment
    • Microservices vs. Monolithic Architecture: Which One to Choose?
    • The Role of Cloud Services in Modern Technical Architecture
    • A getting started guide to Zig
    • Concurrency in Zig
    • DSA using Zig
    • Error Handling in Zig
    • Generics in Zig
    • Pointers in Zig
    • Stack Memory in Zig
    • System Programming in Zig
    • Third Party Dependencies in Zig
     Back to Website
    • to navigate
    • to select
    • to close
      • Home
      • Erlang
      On this page
      code

      Erlang

      Erlang was created by Ericsson’s Computer Science Lab in 1986 for handling large-scale telecommunications projects. Its development was driven by the need for a robust system capable of managing numerous concurrent activities with high levels of fault tolerance.

      code

      A Getting Started Guide with Erlang

      Introduction to Erlang, its history, features, and basics of programming.

      code

      Binaries in Erlang Programming Language

      code

      Concurrency and Process Management in Erlang

      An in-depth look at how Erlang handles concurrency and process management.

      code

      Connecting to SQL Databases Using Erlang's ODBC Library

      code

      Distributed Programming

      code

      Macros in Erlang Programming Language

      code

      Modules in Erlang Programming Language

      code

      Pattern Matching in Erlang

      code

      Practical Applications and Best Practices

      Explore real-world applications and best practices in Erlang programming.

      code

      Understanding Erlang's OTP Framework

      An in-depth guide to Erlang's Open Telecom Platform (OTP) framework.

      code

      Web Programming in Erlang