DEV Community: Mirsoli Mirzaahmad õğli

Nixos config for nvim

Mirsoli Mirzaahmad õğli — Mon, 24 Mar 2025 15:05:27 +0000

How to turn NEOVIM into an IDE-like code editor in NIXOS?

Mirsoli Mirzaahmad õğli ・ Mar 24

How to turn NEOVIM into an IDE-like code editor in NIXOS?

Mirsoli Mirzaahmad õğli — Mon, 24 Mar 2025 15:04:47 +0000

Welcome to my optimized Laravel development setup featuring Nvim with LazyVim integration. This configuration is tailored to enhance productivity and streamline the development workflow for Laravel projects.

Features:

Efficient Code Editing: Leverage the power of Nvim’s fast, extensible code editing with LazyVim’s user-friendly enhancements.
Laravel-Specific Tools: Pre-configured tools and plugins to support Laravel development, including syntax highlighting, code completion, and route navigation.
Enhanced Productivity: Enjoy a suite of features aimed at boosting efficiency, such as automatic code formatting, linting, and integrated terminal support.
Customizable: Easily adapt the setup to your preferences with a modular and customizable configuration.

Setup:

Clone this repository:

git clone https://github.com/codahiri/dotfiles.git ~/.config/nvim

Remove the .git folder, so you can add it to your own repo later

rm -rf ./nvim/.git

Create a folder called neovim and copy the cloned nvim folder into it. Then create a file called deafult.nix and add the following code inside it:

{
  config,
  lib,
  pkgs,
  ...
}:
###############################################################################
#
#  NvChad's configuration and all its dependencies(lsp, formatter, etc.)
#
#e#############################################################################
let
  shellAliases = {
    v = "nvim";
    vdiff = "nvim -d";
  };
  # the path to nvim directory
  # to make this symlink work, we need to git clone this repo to your home directory.
  configPath = "${config.home.homeDirectory}/nixos-config/modules/home/neovim/nvim";
in
{
  xdg.configFile."nvim".source = config.lib.file.mkOutOfStoreSymlink configPath;

  home.shellAliases = shellAliases;
  programs.nushell.shellAliases = shellAliases;

  programs = {
    neovim = {
      enable = true;
      package = pkgs.neovim-unwrapped;

      # defaultEditor = true; # set EDITOR at system-wide level
      viAlias = true;
      vimAlias = true;

      # These environment variables are needed to build and run binaries
      # with external package managers like mason.nvim.
      #
      # LD_LIBRARY_PATH is also needed to run the non-FHS binaries downloaded by mason.nvim.
      # it will be set by nix-ld, so we do not need to set it here again.
      extraWrapperArgs = with pkgs; [
        # LIBRARY_PATH is used by gcc before compilation to search directories
        # containing static and shared libraries that need to be linked to your program.
        "--suffix"
        "LIBRARY_PATH"
        ":"
        "${lib.makeLibraryPath [
          stdenv.cc.cc
          zlib
        ]}"

        # PKG_CONFIG_PATH is used by pkg-config before compilation to search directories
        # containing .pc files that describe the libraries that need to be linked to your program.
        "--suffix"
        "PKG_CONFIG_PATH"
        ":"
        "${lib.makeSearchPathOutput "dev" "lib/pkgconfig" [
          stdenv.cc.cc
          zlib
        ]}"
      ];

      # Currently we use lazy.nvim as neovim's package manager, so comment this one.
      #
      # NOTE: These plugins will not be used by astronvim by default!
      # We should install packages that will compile locally or download FHS binaries via Nix!
      # and use lazy.nvim's `dir` option to specify the package directory in nix store.
      # so that these plugins can work on NixOS.
      #
      # related project:
      #  https://github.com/b-src/lazy-nix-helper.nvim
      # plugins = with pkgs.vimPlugins; [
      #   # search all the plugins using https://search.nixos.org/packages
      #   telescope-fzf-native-nvim

      #   nvim-treesitter.withAllGrammars
      # ];
    };
  };
}

Build NixOS and Start Neovim!

# build nixos
sudo nixos-rebuild switch --flake ./#yourhostname

# start nvim
nvim

To get started, clone the repository and follow the installation instructions in the README. This repository includes all necessary configurations, plugins, and dependencies to get your Laravel development environment up and running quickly.

First dark/light & blog website

Mirsoli Mirzaahmad õğli — Mon, 08 Aug 2022 20:30:11 +0000

I created my first dark/light & blog website. Of course, this is a very simple structure.

Link here

Lesson 08 | Structures

Mirsoli Mirzaahmad õğli — Mon, 11 Apr 2022 18:29:52 +0000

Defining Structures With `struct`

Structures are defined with the struct keyword followed by the structure name. Inside the braces, member variables are declared but not initialized. The given code block defines a structure named Person with declared member variables name and age.

// `struct` keyword and structure name
struct Person{
  // uninitialized member variables
  char* name;
  int age;
};

Initializing Structures With `struct`

Structure data types are initialized using the struct keyword with the defined structure type followed by the name of the variable. The given code block shows two ways to initialize Person type structures named person1 and person2.

// `Person` structure declaration
struct Person{
  char* name;
  int age;
};

// designated initialization with member variable names
struct Person person1 = {.name = "Cosmo", .age = 36};

// implicit initialization following order of member variables
struct Person person2 = {"George", 29};

Custom Data Types With Structures

Structures allow the definition of custom data types that are used to represent complex data. Structure customization provides the flexibility to accurately model real-world data, giving you the ability to access and modify the data from a single defined variable.

Grouping Data Types With Structures

Structures can group different data types together into a single, user-defined type. This differs from arrays which can only group the same data type together into a single type. The given code block defines a structure named Person with different basic data types as member variables.

// `Person` structure definition
struct Person{
  // member variables that vary in type
  char* name;
  int age;
  char middleInitial;
};

Accessing Member Variables With Dot Notation

Initialized structure member variables can be accessed with the dot (.) operator. The given code block initializes a Person type named person1 and accesses the name member variable within a printf() statement.

// `Person` structure declaration
struct Person{
  // member variables
  char* name;
  int age;
  char middleInitial;
};

// initialization of `person1`
struct Person person1 = {.name = "George", .age = 28, .middleInitial = "C"};

// accessing `name` in `person1`
printf("My name is %s", person1.name);
// OUTPUT: My name is George

Structure Member Variables

The variables defined within a structure are known as member variables. The given code block defined a structure named Person with member variables name of type char*, and age of type int.

// Person structure declaration
struct Person{
  // member variables
  char* name;
  int age;
};

Structure Type Pointers

Pointers to a structure can be defined using the struct keyword, the structure type, and the pointer (*) symbol. The memory address of an initialized structure can be accessed using the symbol (&). The given code block defines a pointer to a Person data type named person1.

// Person structure declaration
struct Person{
  // member variables
  char* name;
  int age;
};

// person1 initialization
struct Person person1 = {"George", 28};

// person1Pointer initializated to the memory address of person1
struct Person* person1Pointer = &person1;

Accessing Member Variables With Arrow Notiation

Member variables of a structure can be accessed using a pointer with arrow (->) notation. The given code block initializes a Person pointer type named person1Pointer. Inside the printf() statement, the name member variable of person1 is accessed using arrow (->) notation.

// `Person` structure declaration
struct Person{
  // member variables
  char* name;
  int age;
};

// `person1` intialization
struct Person person1 = {"Jerry", 29};

// `person1Pointer` intialization to memory address to `person1`
struct Person* person1Pointer = &person1;

// accessing `name` through `person1Pointer`
printf("My name is %s", person1Pointer->name);
// OUTPUT: My name is Jerry

Passing Structures To Functions

Structures can be used as parameters of functions by using the struct keyword followed by the structure name in the function definition. The given code block defines a function signature named myFunc() with a Person parameter named person1.

// Person structure declaration
struct Person{
  // member variables
  char* name;
  int age;
};

// declaring Person type parameter
void myFunc(struct Person person1);

Passing Structure Pointers To Functions

Structure pointers can be paramters of functions by using the struct keyword, the structure name, and the pointer symbol (*) in the function definition. The given code block defines a function signature named myFunc() with a Person pointer parameter named person1 pointer.

Lesson 07 | Functions

Mirsoli Mirzaahmad õğli — Mon, 11 Apr 2022 18:19:18 +0000

Functions in C

A function is a block of reusable logic that may have a defined set of input and output.

Built-In Function in C

The C programming language comes with built-in standard library functions, such as:

printf()
rand()

#include <stdio.h>

int main() {
  // printf is a standard library function
  printf("Hello built-in functions!");
}

Calling Functions

In C, a function is called by stating the function name followed by parentheses. One or more argument values can be placed in the parentheses if the function requires any input values.

int incrementBy(int number1, int number2) {
  return number1 + number2;
}

int main() {
  // The value of myNumber is retrieved by
  // calling the function incrementBy() with
  // the arguments 5 and 2
  int myNumber = incrementBy(5, 2);
}

Storing A Return Value

A function return value, or function output, can be stored in a variable to be used for future calculations.

int incrementBy(int number1, int number2) {
  return number1 + number2;
}

int main() {
  // myNumber will hold the return value
  // of increment by, which is 7
  int myNumber = incrementBy(5,2);
}

Function Signature

A user-defined function is defined using a function signature. This signature specifies the return type and the function name followed by parameters inside parentheses.

// A function signature includes the
// return type, function name, and
// parameter(s) in the parentheses
int incrementBy(int number1, number2) {
  return number1 + number2;
}

Return Type void

A function that returns no value must use the keyword void as the return type within the function signature.

// void is used since the function
// printNumnber does not return any value
void printNumber(int number) {
  printf("Your number is %d\n", number);
}

Function Return Value

A user-defined function can return a value with the return keyword followed by the value to be returned. The type of the returned value must match the return type specified in the function signature.

// the return keyword returns the
// value following the keyword
int getOne() {
  return 1;
}

Function Parameters

In C, a user-defined function can specify input using parameters. Parameters are comma-separated variable definitions within the function signature parentheses.

// number1 and number2 are paramters
// for the incrementBy function
void incrementBy(int number1, int number2) {
  return number1 + number2;
}

Function Protypes

A function prototype specifies an interface with the required return type and parameter types to help the compiler ensure a function is called properly. A function prototype also helps separate the function declaration from its implementation.

// function prototpe
int increment(int);

// function implmentation
int increment(int number) {
  return number += 1;
}

Lesson 06 | Pointers and Memory

Mirsoli Mirzaahmad õğli — Mon, 11 Apr 2022 18:13:34 +0000

What is a pointer?

A pointer is a variable that stores the hexadecimal address of the variable it is pointing to.

Declaring Pointers

A pointer variable is declared like so:

type* pntr;
type *pntr;

Accessing Memory Address

A memory address of a variable is obtained using the reference operator (&). Example: &var.

Dereferencing Pointers

A pointer is dereferenced using the dereference operator (*). Example: *pntr.

Incrementing and Decrementing Pointers

Pointers can be incremented and decremented using the + and - arithmetic operators.

Accessing Arrays

Arrays can be accessed by using a pointer to the first element and incrementing and decrementing as necessary.

Lesson 05 |Arrays and Strings

Mirsoli Mirzaahmad õğli — Mon, 11 Apr 2022 18:10:20 +0000

What is an array?

An array is used to store many elements of the same type in contiguous blocks of memory

Creating Uninitialized Arrays

An uninitialized array is created as follows:

type arr[array_size];

Creating an Initialized Array

An initialized array is created as follows:

type arr[] = {element1, element2, element3, …};

Accessing Array Elements

You can access the array element at index idx as follows:

arr[index];

First and Last Array Elements

The first and last elements in the array can be found at the following indices:

firstElement = arr[0];
lastElement = arr[arraySize - 1];

sizeof()

Array size can be found using the sizeof() function

Iterating Through Arrays

Arrays can be iterated through using while loops or for loops.

Invalid Array Access

Attempting to access or modify an element at an index greater than the length of the array will cause the program to behave unpredictably.

Creating Multidimensional Arrays

Initialized and uninitialized multidimensional arrays are created as follows:

initializedMultArray = type arr[][dim2Size]…[dimNSize] = {{element1, element2,…},{element1, element2, …}, …};
uninitializedMultArray = type arr[dim1Size][dim2Size]…[dimNSize];

String Length

Arrays are static, therefore the length of a string cannot be modified.

Accessing Characters in a String

Characters in a string can be accessed and modified using indices, the same technique used with arrays.

Creating Strings

Strings can be created by initializing an array of chars.

Null Character

All strings terminate with a null character ('\0').

strlen()

You can find the length of a string using the strlen() function.

strcat()

Two strings can be concatenated using the strcat() function.

strcpy()

A string can be copied into an empty char array (empty string) using the strcpy() function.

Lasson 04 | Loops and errors

Mirsoli Mirzaahmad õğli — Tue, 29 Mar 2022 15:40:55 +0000

Types of Loops

Loops can be written as while loops, do-while loops, and for loops.

while Loops

while loops iterate until a condition is met.

int a = 0;
while (a < 10) {
  a++;
}

do-while Loops

do-while loops are while loops that initially execute the body once before checking the condition.

do {
  printf("not true!");
} (while 2 == 3);

for Loops

for loops complete a set number of iterations before meeting a condition.

for (int i = 0; i <= 10; i++) {
  printf("Hello!");
}

Loop Keywords

All loops can utilize keywords like continue and break. continue restarts the loop and break breaks out of (or ends) the loop.

Rewriting Loops

A for loop can always be re-written as a while loop; most while loops can be re-written as a for loop.

Lesson 03 | Conditionals

Mirsoli Mirzaahmad õğli — Sat, 26 Mar 2022 06:58:33 +0000

Types of Conditionals

A conditional in C can be written using if, else-if, else, ternary operators, and switch statements.

if Statements

An if statement tests an expression and executes code based on its truth.

if (x == 3) {
  printf("x is 3!");
}

else-if Statements

An else-if statement tests an expression and must come after an existing if or else-if.

if (x > 3) {
  printf("x is greater than 3");
} else if (x < 3) {
  printf("x is less than 3");
}

else Statements

An else statement is accessed when all preceding if and/or else-if statements return false.

if (x > 3) {
  printf("x is greater than 3");
} else if (x < 3) {
  printf("x is less than 3");
} else {
  printf("x equals 3");
}

Dangling else Statement

A dangling else statement results when it’s ambiguous which conditional the else statement is attached to.

Ternary Operators

A ternary operator is a condensed if-else statement.

min = a < b ? a : b; // This is the same as the if-else below

if (a < b) {
  min = a;
} else {
  min = b;
}

switch Statements

A switch statement is a condensed series of cascading else statements. It tests a value and compares it against multiple cases.

switch (grade) {
  case 9:
    printf("Freshman\n");
    break;
  case 10:
    printf("Sophomore\n");
    break;
  case 11:
    printf("Junior\n");
    break;
  case 12:
    printf("Senior\n");
    break;
  default:
    printf("Invalid\n");
    break;
}

Operators and Conditionals

A conditional in C can use relational operators such as &&, ||, and ! to compare values and test multiple expressions.

Lesson 02 | Operators

Mirsoli Mirzaahmad õğli — Thu, 17 Mar 2022 16:45:01 +0000

Mathmatical Symbols in C

C is able to perform basic mathematical operations on variables and values using the following symbols:

Addition: +
Subtraction: -
Division: /
Multiplication: *
Incrementing: ++
Decrementing: --
Modulo: %

Assignment Operations in C

C can assign values to variables and perform basic mathematical operations using shorthand operators:

Assignment: =
Addition then assignment: +=
Subtraction then assignment: -=
Multiplication then assignment: *=
Division then assignment: /=
Modulo then assignment: %=

Comparing values in C

C can compare two values and/or variables against each other to return true or false. The operators are as follows:

Do both sides have the same value? ==
Do the two sides have different values? !=
Is the left side a lower value than the right side? <
Is the left side a lower or equal value to the right side? <=
Is the left side a greater value than the right side? >
Is the left side a greater or equal value to the right side? >=

Logical Operators in C

C can perform logical operations using the following operators:

and: && (Are both sides true?)
or: || (Is at least one side true?)
not: ! (True becomes false and false becomes true.)

Lesson 01 | Variables

Mirsoli Mirzaahmad õğli — Wed, 16 Mar 2022 16:38:16 +0000

C Variable Names

In C variable names must follow specific rules:

Names can only be composed of upper and lower case letters, numbers, and underscores.
The first character must be a letter (upper or lower case).
No keywords are allowed as the full name (int is not allowed but int_count would work).

Data Types in C

The main data types in C are: int, float, double, and char.

Setting Variables in C

Variables in C can be initialized with values at their declaration or have their values set later in the code.

Variable Casting in C

In C a variable can be cast explicitly or implicitly from one data type to another. They can then be used directly or stored in another variable.

Hello Clang | 00

Mirsoli Mirzaahmad õğli — Mon, 14 Mar 2022 16:18:04 +0000

Syntax in C

The rules that dictate the correct format of code for a specific programming language are known as syntax.

Examples of syntax in C are:

All statements must end with a semicolon,;
Keywords and other code elements are case-sensitive

When compiling C code, an error will occur when the syntax of the code is incorrect.

// Statements must end in a semicolon (;)
// correct
printf("Hello World!");

// error
printf("Hello World!")

// Code elements are case sensitive
// correct
printf("Hello World!");

// error
PRINTF("Hello World!");

Escape Sequences

In C, an escape sequence is a non-visual character used within a string.

\n is an escape sequence that adds a newline to a string. \t is an escape sequence that adds a tab of spaces to a string.

// \n acts as a newline in a string
printf("Hello\nWorld!"); // Outputs: Hello
                         //          World!

// \t acts as a tab in a string
printf("Hello\tWorld!"); // Outputs: Hello    World!

Comments in C

In C, comments are text within code that will be ignored by the compiler. They are used to document code.

Line comments begin with a double forward slash, //. All text after // will be part of the comment until a new line is reached.

Block comments begin with a forward slash and asterisk, /* and end with an asterisk and forward slash, */. Block comments can span multiple lines as new lines are part of the comment.

// Comments

/* This review content is
about comments and how they
can be used to document code */

// This is a line comment

/* This is a
block comment */

Compiling C Code with gcc

gcc is an application used to compile C programs into an executable that can run on the target computer. gcc stands for GNU Compiler Collection.

gcc compiles C code using the code file as an unflagged command-line argument. The output executable file will be called a.out. The -o flag followed by some text can be used to designate the name of the output executable file.

gcc script.c
gcc script.c -o myProgram

freeCodeCamp data was used

DEV Community: Mirsoli Mirzaahmad õğli

Nixos config for nvim

How to turn NEOVIM into an IDE-like code editor in NIXOS?

Mirsoli Mirzaahmad õğli ・ Mar 24

How to turn NEOVIM into an IDE-like code editor in NIXOS?

Features:​

Setup​:

First dark/light & blog website

Lesson 08 | Structures

Defining Structures With struct

Initializing Structures With struct

Custom Data Types With Structures

Grouping Data Types With Structures

Accessing Member Variables With Dot Notation

Structure Member Variables

Structure Type Pointers

Accessing Member Variables With Arrow Notiation

Passing Structures To Functions

Passing Structure Pointers To Functions

Lesson 07 | Functions

Functions in C

Built-In Function in C

Calling Functions

Storing A Return Value

Function Signature

Return Type void

Function Return Value

Function Parameters

Function Protypes

Lesson 06 | Pointers and Memory

What is a pointer?

Declaring Pointers

Accessing Memory Address

Dereferencing Pointers

Incrementing and Decrementing Pointers

Accessing Arrays

Lesson 05 |Arrays and Strings

What is an array?

Creating Uninitialized Arrays

Creating an Initialized Array

Accessing Array Elements

First and Last Array Elements

sizeof()

Iterating Through Arrays

Invalid Array Access

Creating Multidimensional Arrays

String Length

Accessing Characters in a String

Creating Strings

Null Character

strlen()

strcat()

strcpy()

Lasson 04 | Loops and errors

Types of Loops

while Loops

do-while Loops

for Loops

Loop Keywords

Rewriting Loops

Lesson 03 | Conditionals

Types of Conditionals

if Statements

else-if Statements

else Statements

Dangling else Statement

Ternary Operators

switch Statements

Operators and Conditionals

Lesson 02 | Operators

Mathmatical Symbols in C

Assignment Operations in C

Comparing values in C

Logical Operators in C

Lesson 01 | Variables

C Variable Names

Data Types in C

Setting Variables in C

Variable Casting in C

Hello Clang | 00

Features:

Setup:

Defining Structures With `struct`

Initializing Structures With `struct`