docs: add all untracked content

This commit is contained in:
Parch Linux Wiki 2025-02-20 07:43:03 +00:00
parent 2c5ff7e2bf
commit 6a8df834e7
63 changed files with 8524 additions and 0 deletions

BIN
512x512.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 64 KiB

527
Docker.md Normal file
View file

@ -0,0 +1,527 @@
---
title: Docker
description:
published: true
date: 2024-07-26T10:03:09.866Z
tags:
editor: markdown
dateCreated: 2024-07-26T10:03:03.792Z
---
# Docker Overview
Docker is a tool for containerization, enabling the sharing of development environments across various operating systems through containers. This accelerates development time and allows team members to share environments without dependency conflicts, as all dependencies are contained and isolated within the container.
# History
Before the concept of containers and environment isolation, virtualization was the main solution for separating development environments from the host system. Users would allocate CPU, memory, and hard space resources to a virtual system, but this approach was not optimal because a significant amount of resources was consumed by the virtual operating system, resulting in slower processing speeds compared to the host system.
With the advent of containers, isolation and separation of different environments became more cost-effective and resource-efficient. Docker is one of the tools that can be used for building and managing containers. If you need to share your development/production environment with others, Docker facilitates this by allowing you to share your container skeleton file (image), speeding up the process. Additionally, other users dont need to worry about resolving dependencies as they are already included in the container.
# Installation and Setup
The [Docker documentation](https://docs.docker.com/engine/install/) provides comprehensive installation instructions for Linux systems. However, distributions based on Arch Linux are not officially supported and the installation is considered unstable.
1. Open your terminal and install Docker using the package manager:
```
sudo pacman -S docker
```
> If you encounter the error `docker not found`, make sure to update your repositories with the command `sudo pacman -Syu`.
2. If you are using systemd as your init system, enable the Docker service with:
```
sudo systemctl enable --now docker.service
```
3. Add your username to the Docker group:
```
sudo usermod -aG docker $USER
```
> To apply the changes, either log out and log back in or use the command `newgrp docker`.
4. Verify the Docker installation by running the hello-world image:
```
docker run hello-world
```
The `run` command executes images, which are blueprints for containers that consist of predefined files and configurations.
To list the images on your system, use `docker images`.
To list active containers, use `docker ps`.
# Docker Hub
[Docker Hub](https://hub.docker.com/) serves as Docker's default repository for downloading and uploading images.
For example, if you want to use nginx as your web server, you can download the nginx image from Docker Hub and create a container from it.
1. Log in to your Docker Hub account with:
```
docker login
```
> If you don't have an account, create one [here](https://app.docker.com/signup).
2. Download the latest nginx image with:
```
docker pull nginx
```
> Unfortunately, Docker Hub is blocked in Iran. If you encounter a 403 error or connection timeout, it is likely due to these restrictions. Refer to the [sanctions workaround](#sanctions-workaround) to resolve this issue.
> nginx web server has [comprehensive documentation](https://wiki.parchlinux.com/fa/Docker) on Docker Hub about working with images and containers.
After downloading the image, create a container for nginx with:
```
docker run --name some-nginx -p 8080:80 -v /some/content:/usr/share/nginx/html:ro -d nginx
```
> If you are using other mirrors like focker.ir to download images, replace `nginx` with `focker.ir/nginx`.
```
docker run --name some-nginx -p 8080:80 -v /some/content:/usr/share/nginx/html:ro -d focker.ir/nginx
```
1. The `--name` flag assigns a name to the container, in this example, `some-nginx`.
2. The `-v` or `--volume` flag shares a (path on the host system) with (a path in the container).
> In this example, the path `/some/content` on the host system is shared with `/usr/share/nginx/html` in the container. For instance, if you create a file named `name.txt` in `/some/content` on the host system, you can find the same file in `/usr/share/nginx/html` within the container.
> The `ro` at the end of the volume flag, separated by `:`, stands for read-only. If you set it to `rw`, it will be read and write.
4. The `-p` or `--port` flag maps a port from the host system to a port in the container.
> In this example, port `8080` on the host system is mapped to port `80` in the container.
3. The `-d` flag runs the process in the background.
# Sanctions Workaround
To bypass sanctions, you can use the following methods:
1. Using DNS
2. Using other mirrors
3. Using proxy client tools such as [Hiddify](https://hiddify.com/) and [Nekoray](https://github.com/MatsuriDayo/nekoray).
## Using Other Mirrors
The simplest method to bypass sanctions is to download images from other repositories, such as focker.ir and ArvanCloud.
ArvanCloud has published a [comprehensive guide](https://www.arvancloud.ir/fa/dev/docker) on this.
In summary, you can use the following command to download images from ArvanCloud:
```
docker pull docker.arvancloud.ir/<ImageName>
```
Similarly, for focker.ir:
```
docker pull focker.ir/<ImageName>
```
## Using DNS
Several internal DNS services are available to bypass sanctions, including [Shecan](https://shecan.ir/), [403](https://403.online/), and [Begzar](https://begzar.ir/).
### Begzar
```
/etc/resolv.conf
nameserver 185.55.226.26
nameserver 185.55.225.25
```
### 403
```
/etc/resolv.conf
nameserver 10.202.10.202
nameserver 10.202.10.102
```
### Shecan
```
/etc/resolv.conf
nameserver 178.22.122.100
nameserver 185.51.200.2
```
# Docker Compose
[Docker Compose](https://docs.docker.com/compose/) is one of Docker's most powerful tools, enabling you to define configurations for multiple containers in a single YAML file. This avoids the need to repeatedly type commands in the terminal or manually write scripts. Instead, you can run all the containers with a single command.
# Flags
Docker provides a set of flags:
### --help
Displays usage information and commands for Docker.
### -D, --debug=true|false
Enables or disables debug mode.
### -H, --host=[unix:///var/run/docker.sock]
Specifies the socket address for the Docker service.
### -l, --log-level=debug|info|warn|error|fatal
Sets the log level (default is info).
### --tls=true|false
Specifies whether to use TLS (default is false).
### --tlscacert=~/.docker/ca.pem
Ensures that the certificates are signed by the specified CA.
### --tlscert=~/.docker/cert.pem
Specifies the client certificate file.
### --tlskey=~/.docker/key.pem
Specifies the client key file.
### --tlsverify=true|false
Enables TLS and verifies remote access.
### -v, --version=true|false
Displays the current version of Docker.
## Commands
Use `docker --help` to review the list of available commands.
### run
Run a new container from an image.
```
docker run hello-world
```
### exec
Execute commands in a running container.
```
docker exec -it my_container bash
```
### ps
List running containers.
```
docker ps
```
### build
Build a Docker image from a Dockerfile.
```
docker build -t my_image .
```
### pull
Download an image from Docker Hub.
```
docker pull nginx
```
### push
Upload an image to Docker Hub.
```
docker push focker.ir/my_image
```
### images
List available images.
```
docker images
```
### login
Log in to Docker Hub.
```
docker login
```
### logout
Log out of Docker Hub.
```
docker logout
```
### search
Search for images on Docker Hub.
```
docker search redis
```
### version
Display the Docker version.
```
docker version
```
### info
Display system-wide information.
```
docker info
```
### attach
Attach to a running container.
```
docker attach my_container
```
### commit
Create a new image from a container's changes.
```
docker commit my_container my_image
```
### cp
Copy files between a container and the host.
```
docker cp my_container:/path/in/container /path/on/host
```
### create
Create a new container.
```
docker create --name my_container ubuntu
```
### diff
Inspect changes to files or directories on a containers filesystem.
```
docker diff my_container
```
### events
Get real-time events from the Docker server.
```
docker events
```
### export
Export a containers filesystem as a tar archive.
```
docker export my_container -o my_container.tar
```
### history
Show the history of an image.
```
docker history ubuntu
```
### import
Create an image from a tarball.
```
docker import my_container.tar my_image
```
### inspect
Return low-level information on Docker objects.
```
docker inspect my_container
```
### kill
Kill a running container.
```
docker kill my_container
```
### load
Load an image from a tar archive.
```
docker load -i my_image.tar
```
### logs
Fetch the logs of a container.
```
docker logs my_container
```
### pause
Pause all processes within one or more containers.
```
docker pause my_container
```
### port
List port mappings or a specific mapping for the container.
```
docker port my_container
```
### rename
Rename a container.
```
docker rename my_container new_container_name
```
### restart
Restart a container.
```
docker restart my_container
```
### rm
Remove one or more containers.
```
docker rm my_container
```
### rmi
Remove one or more images.
```
docker rmi my_image
```
### save
Save one or more images to a tar archive.
```
docker save -o my_image.tar my_image
```
### start
Start one or more stopped containers.
```
docker start my_container
```
### stats
Display a live stream of container(s) resource usage statistics.
```
docker stats my_container
```
### stop
Stop one or more running containers.
```
docker stop my_container
```
### tag
Create a tag for an image.
```
docker tag my_image my_repo/my_image:tag
```
### top
Display the running processes of a container.
```
docker top my_container
```
### unpause
Unpause all processes within one or more containers.
```
docker unpause my_container
```
### update
Update configuration of one or more containers.
```
docker update --cpus=2 my_container
```
### wait
Block until one or more containers stop, then print their exit codes.
```
docker wait my_container
```

163
Gaming.md Normal file
View file

@ -0,0 +1,163 @@
---
title: Gaming on Parch Linux
description: A simple Guide about Gaming on Parch Linux
published: true
date: 2024-05-28T21:50:04.279Z
tags: game, parchlinux, gaming, linux
editor: markdown
dateCreated: 2024-05-16T17:56:46.186Z
---
# Gaming on ParchLinux
Acording to Archlinux wiki:
> Linux has long been considered an "unofficial" gaming platform; the support and target audience provided to it is not a primary priority for most gaming organizations. Changes to this situation have accelerated, starting from 2021 onward, as big players like Valve, the CodeWeavers group and the community have made tremendous improvements to the ecosystem, allowing Linux to truly become a viable platform for gaming. Further, more and more indie development teams strive to use cross-platform rendering engines in order to have their game able to compile and run on Linux.
When it comes to gaming, the majority of user's thoughts are often directed towards popular AAA games which are usually written exclusively for the Microsoft Windows platform. This is understandable, however, it is not the only and sole availability. Please refer to #Game environments and #Getting games further down the page where you can find software to run games from other platforms.
If you however are fixated on getting games written for Microsoft Windows to work on Linux, then a different mindset, tools and approach is required; understanding internals and providing functional substitution.
# Drivers
For better experience in Gaming you need to install some drivers on Parch Linux
## [Intel graphics](https://wiki.archlinux.org/title/Intel_graphics)
For Gen 3 hardware and later intel GPU install ```mesa```^extra^ ```lib32-mesa``` ^multilib^ and for Gen 2 to Gen 11 hardware install ```mesa-amber```^extra^ ```lib32-mesa-amber```^multilib^ .
The ```xf86-video-intel```^extra^ package provides the legacy intel DDX driver from Gen 2 to Gen 9 hardware. This package is generally not recommended.
## [vulkan](https://wiki.archlinux.org/title/Vulkan)
Here are the instructions for installing Vulkan drivers on Intel and AMD graphics cards:
### **For Intel GPUs:**
For Vulkan support (Haswell and newer; support for earlier chips is incomplete or missing), install the ```vulkan-intel```^extra^ package.
For 32-bit Vulkan support, install the ```lib32-vulkan-intel```^multilib^ package.
### **For Nvidia GPUs:**
For NVIDIA GPUs, there are two implementations available:
##### Proprietary Driver
- `nvidia-utils`^extra^ (or `lib32-nvidia-utils`^multilib^ for 32-bit support)
- This is the proprietary driver provided by NVIDIA, which includes an OpenGL implementation.
##### Open-Source Driver
- `vulkan-nouveau`^extra^ (or `lib32-vulkan-nouveau`^multilib^ for 32-bit support)
- This is the open-source NVK driver, which is part of the Mesa project. It provides a Vulkan implementation for NVIDIA GPUs.
### **For AMD GPUs:**
AMD offers two Vulkan driver options:
1. **vulkan-radeon**
RADV (part of Mesa project)
Install ```vulkan-radeon```^extra^ package.
2. **amdvlk**
AMDVLK Open (maintained by AMD)
Install ```amdvlk```^extra^
Additionally, for 32-bit application support, you can install the corresponding `lib32` packages:
- For `vulkan-radeon`: `lib32-vulkan-radeon`^multilib^
- For `amdvlk`: `lib32-amdvlk`^multilib^
After installing the appropriate Vulkan driver, your system should be able to run Vulkan-based applications and games seamlessly.
> ## [AMDGPU](https://wiki.archlinux.org/title/AMDGPU)
> ## [Nvidia](https://wiki.archlinux.org/title/NVIDIA)
## [Mesa](https://mesa3d.org/)
Mesa is an open-source OpenGL implementation, continually updated to support the latest OpenGL specification. It has a collection of open-source drivers for Intel graphics, AMD (formerly ATI), and NVIDIA GPUs. Mesa also provides software rasterizers, such as llvmpipe.
There are two Mesa packages, each with a distinct set of drivers:
### mesa
`mesa` is the up-to-date Mesa package which includes most of the modern drivers for newer hardware:
- `r300`: for AMD's Radeon R300, R400, and R500 GPUs.
- `r600`: for AMD's Radeon R600 GPUs up to Northern Islands. Officially supported by AMD.
- `radeonsi`: for AMD's Southern Island GPUs and later. Officially supported by AMD.
- `nouveau`: Nouveau is the open-source driver for NVIDIA GPUs.
- `virtio_gpu`: a virtual GPU driver for virtio, can be used with QEMU-based VMMs (like KVM or Xen).
- `vmwgfx`: for VMware virtual GPUs.
- `i915`: for Intel's Gen 3 hardware.
- `crocus`: for Intel's Gen 4 to Gen 7 hardware.
- `iris`: for Intel's Gen 8 hardware and later. Officially supported by Intel.
- `zink`: a Gallium driver used to run OpenGL on top of Vulkan.
- `d3d12`: for OpenGL 3.3 support on devices that only support D3D12 (i.e., WSL).
- `softpipe`: a software rasterizer and a reference Gallium driver.
- `llvmpipe`: a software rasterizer which uses LLVM for x86 JIT code generation and is multi-threaded.
### mesa-amber
`mesa-amber` is the legacy Mesa package which includes the classic (non-Gallium3D) drivers for older hardware:
- `i830`: for Intel's Gen 2 hardware. Same binary as `i965`.
- `i915`: for Intel's Gen 3 hardware. Same binary as `i965`.
- `i965`: for Intel's Gen 4 to Gen 11 hardware. Officially supported by Intel.
- `radeon`: for AMD's Radeon R100 GPUs. Same binary as `r200`.
- `r200`: for AMD's Radeon R200 GPUs.
- `nouveau_vieux`: for NVIDIA NV04 (Fahrenheit) to NV20 (Kelvin) GPUs.
- `swrast`: a legacy software rasterizer.
**Note:** When using Mesa, the correct driver should be selected automatically, thus no configuration is needed once the package is installed.
### Proprietary Drivers
- `nvidia-utils` is the proprietary driver for NVIDIA GPUs, which includes an OpenGL implementation.
- `amdgpu-pro-oglp` (AUR) is the proprietary driver for AMD GPUs.
# Gaming Platforms
## Steam
Steam is a popular game distribution platform by Valve.
- for installation just install ```steam```^extra^ package.
## Proton
A compatibility layer that allows Steam to run Windows games on Linux.
We recommend installing Proton with the help of **ProtonUp-Qt**.
## ProtonUp-Qt
A graphical utility for managing and installing different versions of Proton on Steam, allowing you to choose the best version for each game.
- for installation just install ```protonup-qt```^AUR^
## Proton-GE
An optimized and extended version of Proton that provides better performance for running Windows games on Linux.
We recommend installing Proton with the help of **ProtonUp-Qt**.
## [GameMode](https://wiki.archlinux.org/title/Gamemode)
A system utility that applies temporary optimizations to improve game performance on Linux.
- for installation just install ```gamemode```^extra^ ```lib32-gamemode```^extra^ packages
## Wine-GE
An optimized and extended version of Wine **(the Windows compatibility layer for Linux)** that is tailored for running Windows games on Linux.
- for installation just install ```wine-ge-custom```^AUR^
## [Lutris](https://lutris.net/)
An all-in-one application for installing and running Windows and Linux games on Linux, supporting tools like Wine-GE and Proton.
- for installation just install ```lutris```^extra^
### Additional Tips
- Check **[ProtonDB](https://www.protondb.com/)** for compatibility reports and tips on running games better.
- To set the Proton version used in Steam for a game:
1. Right-click the game in your Steam library and select Properties.
2. Go to the Compatibility tab.
3. From the "Use this tool for compatibility" list, select the Proton version you want (e.g., Proton-GE).
- To enable GameMode for a specific Steam game:
1. Right-click the game in your Steam library and select Properties.
2. Go to the Launch Options section.
3. In the text box, enter gamemoderun %command%.
> With this guide, you should be able to take advantage of the powerful gaming tools on ParchLinux for installing and playing games seamlessly. Refer to the official documentation for each tool if you need further information.
>
{.is-success}

153
Gnome.md Normal file
View file

@ -0,0 +1,153 @@
---
title: GNOME Desktop Environment
description:
published: true
date: 2024-10-01T11:10:56.171Z
tags: gnome
editor: markdown
dateCreated: 2024-10-01T10:43:58.594Z
---
# What is GNOME?
> GNOME (/(ɡ)noʊm/) is a desktop environment that aims to be simple and easy to use. It is designed by The GNOME Project and is composed entirely of free and open-source software.
### Screenshot of Gnome in Parch Linux
![screenshot](https://github.com/parchlinux/Parch-iso-gnome/raw/main/image/screenshot.png)
## Moving from another Desktop to Gnome
For installing Gnome on Parch Linux you need to install our meta package.
```bash
sudo pacman -S parch-gnome-meta
```
this would install a minimal gnome session with parch customization on Parch Linux.
### enabling the display manager
if you are moving from KDE or other desktops (by default parch uses sddm in all editions except Gnome) you need to disable your old login manager and then enable GDM .
```bash
# disabling old login manager (sddm)
sudo systemctl disable sddm
#enabling GDM
sudo systemctl enable gdm
```
## Tips and Tricks
### Enabling numlock on GNOME startup
You need to run this command in terminal for enabling this behavior:
```bash
gsettings set org.gnome.desktop.peripherals.keyboard numlock-state true
```
To remember the last state:
```bash
gsettings set org.gnome.desktop.peripherals.keyboard remember-numlock-state true
```
### Redirect certain URLs to specific web browsers
This shows how to use Chromium for certain types of URLs while maintaining Firefox as default browser for all other tasks.
Make sure pcre is installed, to use pcregrep.
Setup custom xdg-open:
```
/usr/local/bin/xdg-open
```
```
#!/bin/bash
DOMAIN_LIST_FILE=~/'domains.txt'
OTHER_BROWSER='/usr/bin/chromium-browser'
BROWSER_OPTIONS='' # Optional, for command line options passed to browser
XDG_OPEN='/usr/bin/xdg-open'
DEFAULT_BROWSER='/usr/bin/firefox'
if echo "$1" | pcregrep -q '^https?://'; then
matching=0
while read domain; do
if echo "$1" | pcregrep -q "^https?://${domain}"; then
matching=1
break
fi
done < "$DOMAIN_LIST_FILE"
if [[ $matching -eq 1 ]]; then
"$OTHER_BROWSER" $BROWSER_OPTIONS ${*}
exit 0
fi
"$DEFAULT_BROWSER" ${*}
exit 0
else
"$XDG_OPEN" ${*}
fi
```
Configure domains for redirect to Chromium:
```
$HOME/domains.txt
```
```
stackexchange.com
stackoverflow.com
superuser.com
www.youtube.com
github.com
```
Setup xdg-open web as desktop application:
```
$HOME/.local/share/applications/xdg-open-web.desktop
```
```
[Desktop Entry]
Version=1.0
Name=xdg-open web
GenericName=Web Browser
Exec=xdg-open %u
Terminal=false
Type=Application
MimeType=text/html;text/xml;application/xhtml+xml;application/vnd.mozilla.xul+xml;text/mml;x-scheme-handler/http;x-scheme-handler/https;
StartupNotify=true
Categories=Network;WebBrowser;
Keywords=web;browser;internet;
Actions=new-window;new-private-window;
```
```
$ update-desktop-database $HOME/.local/share/applications/
```
Set xdg-open web as default Web application in GNOME settings: Go to GNOME Settings > Details > Default Applications and set Web to xdg-open web
### Custom GNOME sessions
It is possible to create custom GNOME sessions which use the GNOME session manager but start different sets of components (Openbox with tint2 instead of GNOME Shell for example).
Two files are required for a custom GNOME session: a session file in ```/usr/share/gnome-session/sessions/``` which defines the components to be started and a desktop entry in `/usr/share/xsessions` which is read by the display manager. An example session file is provided below:
```
/usr/share/gnome-session/sessions/gnome-openbox.session
```
```
[GNOME Session]
Name=GNOME Openbox
RequiredComponents=openbox;tint2;gnome-settings-daemon;
```
And an example desktop file:
```
/usr/share/xsessions/gnome-openbox.desktop
```
```
[Desktop Entry]
Name=GNOME Openbox
Exec=gnome-session --session=gnome-openbox
```

92
IDEs.md Normal file
View file

@ -0,0 +1,92 @@
---
title: IDEs in Parch
description: Introduction and tutorial for installing popular IDEs on Parch Linux
published: true
date: 2025-02-13T07:51:44.751Z
tags: ide, ides, vscode, code, jetbrains, editor, development, programing
editor: markdown
dateCreated: 2025-02-08T12:54:47.718Z
---
# Integrated Development Environment (IDE)
## Overview
Integrated Development Environments (IDEs) are environments that include a text editor, project management tools, a debugger, and other tools for software development.
## Popular IDEs
### 1. **Visual Studio Code**
Visual Studio Code (VS Code) is one of the most popular and widely used code editors developed by Microsoft.
#### Available Versions:
- **Code - OSS**: The official open-source package from Arch Linux. This version includes a configuration to enable [Open VSX](https://open-vsx.org/).
**Installation:**
```bash
sudo pacman -S code
```
- **Visual Studio Code**: The proprietary version owned by Microsoft.
**Installation:**
```bash
yay -S visual-studio-code-bin
```
- **VSCodium**: A community-driven free version that does not send telemetry data to service providers and provides [Open VSX](https://open-vsx.org/) support.
**Installation:**
```bash
yay -S vscodium
```
### 2. **JetBrains IntelliJ IDEA**
IntelliJ IDEA is a professional IDE for Java software development. It offers powerful features for code development, project management, and testing.
**Installation:**
```bash
sudo pacman -S intellij-idea-community-edition
```
### 3. **Eclipse**
Eclipse is a free IDE for Java software development that supports multiple programming languages.
**Installation:**
```bash
sudo pacman -S eclipse-java-bin
```
### 4. **PyCharm**
PyCharm is a dedicated IDE for the Python programming language developed by JetBrains.
**Installation:**
```bash
sudo pacman -S pycharm-community-edition
```
### 5. **Zed**
Zed is a new code editor built with the Rust programming language, focusing on speed, collaboration, and artificial intelligence (AI), supporting various programming languages.
**Installation:**
```bash
sudo pacman -S zed
```
### 6. **Atom/Pulsar**
Pulsar is an open-source text editor that continues the development of Atom after GitHub officially ceased its development. It is designed for a lightweight and customizable experience.
**Installation:**
```bash
yay -S pulsar
```
### 7. **NetBeans**
NetBeans is a free and powerful IDE developed by Oracle, primarily designed for Java software development. It also supports other programming languages.
**Installation:**
```bash
sudo pacman -S netbeans
```
### 8. **All JetBrains products**
JetBrains Toolbox is a tool that allows you to easily manage and install JetBrains IDEs, such as IntelliJ IDEA, PyCharm, WebStorm, and more. It provides automatic updates and the ability to switch between different versions of JetBrains products.
**Installation:**
```bash
sudo pacman -S jetbrains-toolbox
```
### 9. **Vim/NeoVim**
NeoVim alone is not a complete IDE, but with the use of numerous plugins developed for it, it can be transformed into a development environment similar to an IDE.
> For more details about NeoVim and how to convert it into a full-fledged IDE, you can refer to the [NeoVim page](https://wiki.parchlinux.com/en/neovim) in the Parch Wiki.
{.is-info}

12
Installation-Guide.md Normal file
View file

@ -0,0 +1,12 @@
---
title: Installation Guide
description:
published: true
date: 2024-05-04T07:43:39.604Z
tags: parch, installation guide
editor: markdown
dateCreated: 2024-05-04T07:43:29.755Z
---
# How to Install Parch Linux?
Your co

93
Package-management.md Normal file
View file

@ -0,0 +1,93 @@
---
title: Package Management
description:
published: true
date: 2024-05-05T15:19:05.888Z
tags:
editor: markdown
dateCreated: 2024-05-05T14:49:35.443Z
---
# Package Management in Parch Linux
## Package Manager
The package manager in Parch Linux is called pacman.
Acording to The ArchLinux wiki:
>The pacman package manager is one of the major distinguishing features of Arch Linux. It combines a simple binary package format with an easy-to-use build system. The goal of pacman is to make it possible to easily manage packages, whether they are from the official repositories or the user's own builds.
Pacman keeps the system up-to-date by synchronizing package lists with the master server. This server/client model also allows the user to download/install packages with a simple command, complete with all required dependencies.
Pacman is written in the C programming language and uses the bsdtar(1) tar format for packaging.
## How does pacman works?
Here is a small cheatsheet that helps you to use pacman:
## Basic operations
| Action | Arch | Red Hat/Fedora | Debian/Ubuntu | SLES/openSUSE | Gentoo |
|--------|------|-----------------|----------------|-----------------|--------|
| Search for package(s) | `pacman -Ss` | `dnf search` | `apt search` | `zypper search` or `zypper se [-s]` | `emerge --search` (`-s`) or `emerge --searchdesc` (`-S`) |
| Install package(s) by name | `pacman -S` | `dnf install` | `apt install` | `zypper install` or `zypper in` | `emerge` |
| Get source package(s) and build dependencies | `makepkg -s PKGBUILD` | `dnf builddep` | `apt build-dep` | `zypper source-install` (`zypper si`) or `zypper install -d` | `emerge`, or explicitly `emerge --with-bdeps` |
| Print targets without performing the operation | `pacman --print` (or `-p`) | `dnf --setopt=tsflags=test` | `apt --simulate` (or `-s`, `--dry-run`, `--just-print`) | `zypper --dry-run` | `emerge --pretend` (`-p`) |
| Toggle confirmations | `pacman --confirm` or `pacman --noconfirm` | `dnf --assumeyes` (`-y`) or `dnf --assumeno` | `apt --yes` (`-y`) | `zypper --non-interactive` (`-n`) or `zypper --no-confirm` (`-y`) | `emerge --ask` (`-a`) |
| Refresh local package repository | `pacman -Sy` | `dnf check-update` or `dnf makecache` or `dnf upgrade` | `apt update` | `zypper refresh` or `zypper ref` `[-s]` | `emerge --sync` |
| Upgrade Packages | `pacman -Syu` | `dnf upgrade` | `apt upgrade` | `zypper update` or `zypper up` | `emerge -[a]uDN @world` |
| Upgrade Packages (complex updates) | `pacman -Syu` | `dnf distro-sync` | `apt dist-upgrade` | `zypper dup` | `emerge -[a]uDN @world` |
| Remove a package(s) and dependencies | `pacman -Rs` | `dnf remove` | `apt autoremove` | `zypper remove` or `zypper rm` | `emerge --depclean` (`-c`) |
| Remove package(s) and configuration files | `pacman -Rn` | ? | `apt purge` | ? | n/a |
| Remove package(s), dependencies, and config files | `pacman -Rns` | ? | `apt autoremove --purge` | ? | n/a |
| Remove unneeded dependencies | `pacman -Qdtq | pacman -Rs -` `` (`-Qdttq` for optional deps)| `dnf autoremove` | `apt autoremove` | `zypper rm -u` or `zypper packages --unneeded` | `emerge --depclean` (`-c`) |
| Remove packages not in repositories | ```pacman -Rs $(pacman -Qmq)``` | `dnf repoquery --extras` | `aptitude purge '~o'` || ? |
| Mark installed package as explicitly required | `pacman -D --asexplicit` | `dnf mark install` | `apt-mark manual` | `zypper install --force` | `emerge --select` (`-w`) |
| Install package(s) as dependency | `pacman -S --asdeps` | `dnf install` then `dnf mark remove` | `apt-mark auto` | n/a ([workaround](https://bugzilla.opensuse.org/show_bug.cgi?id=1175678)) | `emerge --oneshot` (`-1`) |
| Only download package(s) | `pacman -Sw` | `dnf download` | `apt install --download-only` or `apt download` | `zypper --download-only` | `emerge --fetchonly` (`-f`) |
| Clean up local caches | `pacman -Sc` or `pacman -Scc` | `dnf clean all` | `apt autoclean` or `apt clean` | `zypper clean` | `eclean distfiles` |
| Start a shell | | `dnf shell` | | `zypper shell` ||
## Querying specific packages
| Action | Arch | Red Hat/Fedora | Debian/Ubuntu | SLES/openSUSE | Gentoo |
|--------|------|-----------------|----------------|-----------------|--------|
| Show package information | `pacman -Si` or `pacman -Qi` | `dnf list` or `dnf info` | `apt show` or `apt-cache policy` | `zypper info` or `zypper if` | `emerge -S`, `emerge -pv` or `eix` |
| Display local package info | `pacman -Qi` | `rpm -qi` / `dnf info installed` | `dpkg -s` or `aptitude show` | `zypper --no-remote info` or `rpm -qi` | `emerge -pv` or `emerge -S` |
| Display remote package info | `pacman -Si` | `dnf info` | `apt-cache show` or `aptitude show` | `zypper info` | `emerge -pv` and `emerge -S` or `equery meta` |
| Display local package files | `pacman -Ql` | `rpm -ql` | `dpkg -L` | `rpm -ql` | `equery files` or `qlist` |
| Display remote package files | `pacman -Fl` | `dnf repoquery -l` or `repoquery -l` | `apt-file list` || `pfl` |
| Query package providing file | `pacman -Qo` | `rpm -qf` (installed) or `dnf provides` (everything) or `repoquery -f` | `dpkg -S` or `dlocate` | `rpm -qf` (installed) or `zypper search -f` (everything) | `equery belongs` or `qfile` |
| List files in package | `pacman -Ql` or `pacman -Fl` | `dnf repoquery -l` | `dpkg-query -L` | `rpm -ql` | `equery files` or `qlist` |
| Show reverse provides | `pacman -F` | `dnf provides` | `apt-file search` | `zypper what-provides` or `zypper wp` (exact)
or `zypper se --provides` (fuzzy) | `equery belongs` (installed) or `pfl` |
| Search package by file | `pacman -F` | `dnf provides` | `apt-file search` or `auto-apt` | `zypper search -f` | `equery belongs` or `qfile` |
| Show package changelog | `pacman -Qc` | `dnf changelog` | `apt-get changelog` | `rpm -q --changelog` | `equery changes -f` |
## AUR
> The Arch User Repository (AUR) is a community-driven repository for Arch users. It contains package descriptions (PKGBUILDs) that allow you to compile a package from source with makepkg and then install it via pacman. The AUR was created to organize and share new packages from the community and to help expedite popular packages' inclusion into the extra repository.
A good number of new packages that enter the official repositories start in the AUR. In the AUR, users are able to contribute their own package builds (PKGBUILD and related files). The AUR community has the ability to vote for packages in the AUR. If a package becomes popular enough — provided it has a compatible license and good packaging technique — it may be entered into the extra repository (directly accessible by pacman or from the Arch build system).
### AUR Manager
Parch Linux has Paru as is AUR Manager.
using Paru is just like using pacman, with the same syntax you can easly install packages from AUR.
#### Using Paru
Here are some useful paru commands:
| Command | Description |
| --- | --- |
| `paru` | Update the entire system |
| `paru -Syu` | Update the entire system |
| `paru -S appname` | Install the program from AUR |
| `paru appname` | Install the program from AUR, choosing from the list |
| `paru -Sc` | Remove Pacman and Paru caches |
| `paru -Ss appname` | Search for a package |

29
Pacman-Tricks.md Normal file
View file

@ -0,0 +1,29 @@
---
title: Pacman Tricks
description: Useful tricks you should know for Pacman
published: false
date: 2024-10-20T12:56:18.952Z
tags: tips, tricks, pacman
editor: markdown
dateCreated: 2024-10-20T12:55:19.914Z
---
## About `pacman` command
[`pacman`](https://wiki.archlinux.org/title/Pacman) [package manager](https://en.wikipedia.org/wiki/Package_manager) is one of the most used commands in Arch Linux (or every other Arch-based distros).
> It combines a simple binary package format with an easy-to-use [Arch build system](https://wiki.archlinux.org/title/Arch_build_system). The goal of *pacman* is to make it possible to easily manage packages, whether they are from the [official repositories](https://wiki.archlinux.org/title/Official_repositories) or the user's own builds.
Pacman keeps your system up-to-date by syncing package lists with the master mirror server.
Read more about [*pacman* in Arch Linux Wiki](https://wiki.archlinux.org/title/Pacman).
## Removing unused packages (orphans)
> Orphans are packages that were installed as a dependency and are no longer required by any package.
For example, you may install a package (`package-one`) that requires `package-two` as a dependency. After some time, you may remove the `package-one`, but the `package-two` is still available on your system, though no other package is dependent on that.
In the example above, the `package-two` is an orphan package, because neither the user or any other package uses it.
There's a nice way to view the list of these orphan packages:

36
Tips-and-tricks.md Normal file
View file

@ -0,0 +1,36 @@
---
title: Tips and Tricks
description:
published: true
date: 2024-04-05T10:27:08.108Z
tags: tips, tricks
editor: markdown
dateCreated: 2024-04-05T10:25:57.151Z
---
# Tips and Tricks
## GPG Signature is not valid
If you are downloading a new application or upgrading a system and you face the problem that indicates the GPG Signature is not valid, you should to this things:
### Update the archlinux-keyring package
if the problem with gpg is comming from archlinux packages, you need to reinstall this package to get latest keys.
```bash
sudo pacman -Sy
sudo pacman -S archlinux-keyring
```
## Live system root space size is low
If you need to use Parch Linux live and you need more space for the live root, you need to run this command:
```bash
sudo mount -o remount,size=1G /run/archiso/cowspace
```
The command Above would increase the root file system to 1G , if you need more space change the 1G in command to something else for example: 4G

50
Virtualization.html Normal file
View file

@ -0,0 +1,50 @@
<!--
title: Virtualization on Parch Linux
description: Virtualization is creating a virtual machine, containing an OS that works within your main system.
published: true
date: 2024-05-21T21:15:23.646Z
tags: parch, virtual, virtualization
editor: ckeditor
dateCreated: 2024-05-21T18:48:02.541Z
-->
<h2>What is <strong>virtualization?</strong></h2>
<p>From <a href="https://en.wikipedia.org/wiki/Virtualization">Wikipedia</a>:</p>
<blockquote>
<p>In computing, <strong>virtualization</strong> is the act of creating a virtual (rather than actual) version of something at the same abstraction level, including virtual <a href="https://en.wikipedia.org/wiki/Computer_hardware">computer hardware</a> platforms, <a href="https://en.wikipedia.org/wiki/Data_storage_device">storage devices</a>, and <a href="https://en.wikipedia.org/wiki/Computer_network">computer network</a> resources.</p>
</blockquote>
<p>A virtual machine is a simulated computer running inside another computer. The simulated computer is often called guest, while the real machine is called host.</p>
<p>Popular examples of virtualization client softwares includes <a href="https://www.virtualbox.org/">Oracle VirtualBox</a>, <a href="https://help.gnome.org/users/gnome-boxes/stable/">GNOME Boxes</a>, <a href="https://www.vmware.com/products/workstation-player.html">VMware Workstation</a> <i>(Not FOSS)</i> and <a href="https://www.qemu.org/">QEMU</a>.</p>
<p><i>While you're free to choose what client software you want to use, <strong>we recommend you to use </strong></i><a href="https://help.gnome.org/users/gnome-boxes/stable/"><i><strong>GNOME Boxes</strong></i></a><i>.</i></p>
<h2>GNOME Boxes</h2>
<blockquote>
<p>Boxes is an application that gives you access to virtual machines, running locally or remotely. It also allows you to connect to the display of a remote computer.</p>
</blockquote>
<h3>Installing Boxes</h3>
<p>Installing Boxes on Parch is easy as alphabet. All you have to do is to run <code>sudo pacman -S gnome-boxes</code> in your terminal and reboot afterwards. You'll see Boxes after your computer boots up.</p>
<h2>Oracle VirtualBox</h2>
<blockquote>
<p>VirtualBox is a powerful x86 and AMD64/Intel64 <a href="https://www.virtualbox.org/wiki/Virtualization">virtualization</a> product for enterprise as well as home use. Not only is VirtualBox an extremely feature rich, high performance product for enterprise customers, it is also the only professional solution that is freely available as Open Source Software under the terms of the <a href="https://www.virtualbox.org/wiki/GPLv3">GNU General Public License (GPL) version 3</a>.</p>
</blockquote>
<h3>Installing VirtualBox</h3>
<p>You can install the core package of VirtualBox by running <code>sudo pacman -S virtualbox</code>.</p>
<p>Next, you should run <code>sudo pacman -S virtualbox-host-dkms</code>.&nbsp;</p>
<p>To compile the VirtualBox modules provided by <a href="https://archlinux.org/packages/?name=virtualbox-host-dkms">virtualbox-host-dkms</a>, you'll also need to to install the appropriate headers packages for your installed kernel, for example:</p>
<ul>
<li><code>sudo pacman -S linux-headers</code>&nbsp;for <a href="https://archlinux.org/packages/?name=linux">Linux</a> kernel</li>
<li><code>sudo pacman -S linux-lts-headers</code> for Linux-LTS kernel</li>
<li><code>sudo pacman -S linux-zen-headers</code> for Linux-ZEN kernel</li>
<li><code>sudo pacman -S linux-hardened-headers</code> for Linux-HARDENED kernel</li>
</ul>
<p>Don't forget to reboot after installing.</p>
<h3>Enabling additional features of VirtualBox</h3>
<blockquote>
<p>The <i>Oracle VirtualBox Extension Pack</i> provides <a href="https://www.virtualbox.org/manual/ch01.html#intro-installing">additional features</a> and is released under a non-free license <strong>only available for personal use</strong>. To install it, the <a href="https://aur.archlinux.org/packages/virtualbox-ext-oracle/">virtualbox-ext-oracle</a><sup>AUR</sup> package is available.</p>
</blockquote>
<p>For some reasons, additional features on VirtualBox <i>(e.g. mounting an external media device like an USB stick to the guest) </i>are not included in the core package and you need to install the extension pack to use these features.</p>
<p>You can install this package and use these features by:&nbsp;</p>
<ol>
<li>Running <code>paru -S virtualbox-ext-oracle --noconfirm</code> on your terminal. (<code><i>paru</i></code><i> </i>comes included by default in Parch Linux, but you may want to use <code><i>yay</i></code><i> </i>or <code><i>aura</i></code><i> </i>instead.)</li>
<li>Running <code>sudo usermod -aG vboxusers <i>YOUR-USERNAME</i></code><i> </i>on your terminal. (Put your username instead of <code><i>YOUR-USERNAME</i></code><i> </i>in the command.)</li>
</ol>
<p>At the end, don't forget to reboot, since it is necessary.</p>

13
ar/home.md Normal file
View file

@ -0,0 +1,13 @@
---
title: الصفحة الرئيسية
description:
published: true
date: 2024-12-26T13:56:35.291Z
tags:
editor: markdown
dateCreated: 2024-12-26T13:56:32.394Z
---
# مرحبًا بكم في ويكي بارش لينكس!
هذه هي الويكي الرسمية لبارش لينكس.
يمكنك **البحث عن حلول لمشاكلك** وأيضًا تعلم أشياء جديدة.

View file

@ -0,0 +1,66 @@
---
title: Choosing the right version
description:
published: true
date: 2024-05-05T09:53:21.241Z
tags:
editor: markdown
dateCreated: 2024-05-05T09:53:15.593Z
---
# Which version of Parch Linux is right for me?
## Parch Linux Plasma Edition
### What is Plasma Desktop?
KDE Plasma is a feature-rich and highly customizable desktop environment that offers a modern and intuitive user experience. It is known for its flexibility, extensive customization options, and a wide range of applications and tools.
![screenshot](https://github.com/parchlinux/parch-iso-plasma/raw/main/image/screenshot.png)
### Pre-Installed Applications
| Name | Usage | Category |
|--------------|-----------|------------|
| Tokodon | A client to Browse the fediverse. | Social |
| Neochat | A client to Browse the [Matrix]. | Social |
| PlasmaTube | A client to watch peertube and piped youtube | Movie & Music |
| VLC | A Video Player written in QT | Movie & Music |
| Elisa | A Simple and easy to use Music Player written in cpp and Kirigami | Movie & Music |
| Firefox | Fast, Private & Safe Web Browser | Web Browser |
| MarkNote | Take notes in Markdown | Productivity |
## Parch Linux Gnome Edition
### What is Gnome Desktop?
GNOME is a user-friendly and modern desktop environment that provides a seamless and intuitive user experience. It is designed with simplicity, accessibility, and customization in mind. GNOME offers a wide range of features and applications, including a file manager, a web browser, a text editor, and a variety of productivity tools.
![screenshot](https://github.com/parchlinux/Parch-iso-gnome/raw/main/image/screenshot.png)
### Pre-Installed Applications in Gnome
| Name | Usage | Category |
|--------------|-----------|------------|
| Tuba | A client to Browse the fediverse. | Social |
| Fractal | A client to Browse the [Matrix]. | Social |
| PipeLine | A client to watch peertube and piped youtube | Movie & Music |
| Celluloid | A MPV front-end written in GTK | Movie & Music |
| G4Music | A Simple and easy to use Music Player written in vala and GTK | Movie & Music |
| Firefox | Fast, Private & Safe Web Browser | Web Browser |
| Folio | Take notes in Markdown | Productivity |
## Which one to choose?
| Gnome | Plasma |
|-----|------|
| Less features | More features|
| Less customization, but simpler | More customization, but steeper learning curve|
| Better GTK support | Better QT support|

162
de/Gaming.md Normal file
View file

@ -0,0 +1,162 @@
---
title: Gaming auf Parch Linux
description:
published: true
date: 2024-10-17T16:54:54.697Z
tags: game, parchlinux, gaming, linux
editor: markdown
dateCreated: 2024-10-17T16:54:51.193Z
---
# Gaming auf Parch Linux
Laut Archlinux-Wiki:
> Linux galt lange Zeit als „inoffizielle“ Gaming-Plattform; die Unterstützung und Zielgruppe, die es bietet, haben für die meisten Gaming-Organisationen keine oberste Priorität. Die Änderungen dieser Situation haben sich ab 2021 beschleunigt, da große Player wie Valve, die CodeWeavers-Gruppe und die Community enorme Verbesserungen am Ökosystem vorgenommen haben, wodurch Linux wirklich zu einer brauchbaren Plattform für Gaming wurde. Darüber hinaus bemühen sich immer mehr Indie-Entwicklungsteams, plattformübergreifende Rendering-Engines zu verwenden, damit ihre Spiele unter Linux kompiliert und ausgeführt werden können.
Wenn es um Gaming geht, richten sich die Gedanken der meisten Benutzer oft auf beliebte AAA-Spiele, die normalerweise exklusiv für die Microsoft Windows-Plattform geschrieben werden. Das ist verständlich, es ist jedoch nicht die einzige und alleinige Verfügbarkeit. Bitte lesen Sie weiter unten auf der Seite #Spielumgebungen und #Spiele abrufen, wo Sie Software zum Ausführen von Spielen von anderen Plattformen finden.
Wenn Sie jedoch darauf fixiert sind, Spiele, die für Microsoft Windows geschrieben wurden, unter Linux laufen zu lassen, dann sind eine andere Denkweise, andere Tools und ein anderer Ansatz erforderlich: Verständnis der internen Vorgänge und Bereitstellung eines funktionalen Ersatzes.
# Drivers
Für ein besseres Gaming-Erlebnis müssen Sie einige Treiber auf Parch Linux installieren
## [Intel graphics](https://wiki.archlinux.org/title/Intel_graphics)
Installieren Sie für Hardware der 3. Generation und spätere Intel-GPUs ```mesa```^extra^ ```lib32-mesa``` ^multilib^ und für Hardware der 2. bis 11. Generation installieren Sie ```mesa-amber```^extra^ ```lib32-mesa-amber```^multilib^.
Das Paket ```xf86-video-intel```^extra^ stellt den älteren Intel DDX-Treiber für Hardware der Generation 2 bis 9 bereit. Dieses Paket wird im Allgemeinen nicht empfohlen.
## [vulkan](https://wiki.archlinux.org/title/Vulkan)
Hier finden Sie die Anweisungen zur Installation von Vulkan-Treibern auf Intel- und AMD-Grafikkarten:
### **Für Intel GPUs:**
Installieren Sie für Vulkan-Unterstützung (Haswell und neuer; die Unterstützung für frühere Chips ist unvollständig oder fehlt) das Paket ```vulkan-intel``` ^extra^.
Installieren Sie für 32-Bit-Vulkan-Unterstützung das Paket ```lib32-vulkan-intel```^multilib^.
### **Für Nvidia GPUs:**
Für NVIDIA-GPUs stehen zwei Implementierungen zur Verfügung:
##### Proprietärer Driver
- `nvidia-utils`^extra^ (oder `lib32-nvidia-utils`^multilib^ für 32-Bit-Unterstützung)
- Dies ist der proprietäre Treiber von NVIDIA, der eine OpenGL-Implementierung enthält.
##### Open-Source Driver
- `vulkan-nouveau`^extra^ (oder `lib32-vulkan-nouveau`^multilib^ für 32-Bit-Unterstützung)
- Dies ist der Open-Source-NVK-Treiber, der Teil des Mesa-Projekts ist. Er bietet eine Vulkan-Implementierung für NVIDIA-GPUs.
### **Für AMD GPUs:**
AMD bietet zwei Vulkan-Treiberoptionen:
1. **vulkan-radeon**
RADV (Teil des Mesa-Projekts)
Installieren Sie das Paket ```vulkan-radeon```^extra^.
2. **amdvlk**
AMDVLK Open (gepflegt von AMD)
Installieren ```amdvlk```^extra^
Darüber hinaus können Sie zur Unterstützung von 32-Bit-Anwendungen die entsprechenden `lib32` Pakete installieren:
- für `vulkan-radeon`: `lib32-vulkan-radeon`^multilib^
- für `amdvlk`: `lib32-amdvlk`^multilib^
Nach der Installation des entsprechenden Vulkan-Treibers sollte Ihr System in der Lage sein, Vulkan-basierte Anwendungen und Spiele reibungslos auszuführen.
> ## [AMDGPU](https://wiki.archlinux.org/title/AMDGPU)
> ## [Nvidia](https://wiki.archlinux.org/title/NVIDIA)
## [Mesa](https://mesa3d.org/)
Mesa ist eine Open-Source-OpenGL-Implementierung, die ständig aktualisiert wird, um die neueste OpenGL-Spezifikation zu unterstützen. Es verfügt über eine Sammlung von Open-Source-Treibern für Intel-Grafiken, AMD (früher ATI) und NVIDIA-GPUs. Mesa bietet auch Software-Rasterizer wie llvmpipe.
Es gibt zwei Mesa-Pakete, jedes mit einem unterschiedlichen Treibersatz:
### mesa
`mesa` ist das aktuelle Mesa-Paket, das die meisten modernen Treiber für neuere Hardware enthält:
- `r300`: für AMDs Radeon R300, R400, und R500 GPUs.
- `r600`: für AMDs Radeon R600 GPUs bis Northern Islands. Offiziell von AMD unterstützt.
- `radeonsi`: für AMDs Southern Island GPUs und höher. Offiziell von AMD unterstützt.
- `nouveau`: Nouveau ist der Open-Source-Treiber für NVIDIA-GPUs.
- `virtio_gpu`: ein virtueller GPU-Treiber für Virtio, kann mit QEMU-basierten VMMs (wie KVM oder Xen) verwendet werden.
- `vmwgfx`: für virtuelle VMware-GPUs.
- `i915`: für Intels Gen 3-Hardware.
- `crocus`: für Intels Hardware der 4. bis 7. Generation.
- `iris`: für Intel-Hardware der 8. Generation und höher. Offiziell von Intel unterstützt.
- `zink`: Ein Gallium-Treiber, der zum Ausführen von OpenGL auf Vulkan verwendet wird.
- `d3d12`: für OpenGL 3.3-Unterstützung auf Geräten, die nur D3D12 unterstützen (d. h. WSL).
- `softpipe`: ein Software-Rasterizer und ein Referenz-Gallium-Treiber.
- `llvmpipe`: ein Software-Rasterizer, der LLVM zur x86-JIT-Codegenerierung verwendet und über mehrere Threads verfügt.
### mesa-amber
`mesa-amber` ist das alte Mesa-Paket, das die klassischen (nicht Gallium3D-)Treiber für ältere Hardware enthält:
- `i830`: für Intels Gen 2-Hardware. Gleiche Binärdatei wie `i965`.
- `i915`: für Intels Gen 3-Hardware. Gleiche Binärdatei wie `i965`.
- `i965`: für Intels Gen 4- bis Gen 11-Hardware. Offiziell von Intel unterstützt.
- `radeon`: für AMDs Radeon R100-GPUs. Gleiche Binärdatei wie `r200`.
- `r200`: für AMDs Radeon R200-GPUs.
- `nouveau_vieux`: für NVIDIA NV04 (Fahrenheit) bis NV20 (Kelvin) GPUs.
- `swrast`: ein veralteter Software-Rasterizer.
**Hinweis:** Bei Verwendung von Mesa sollte der richtige Treiber automatisch ausgewählt werden, sodass nach der Installation des Pakets keine Konfiguration erforderlich ist.
### Proprietärer Drivers
- `nvidia-utils` ist der proprietäre Treiber für NVIDIA-GPUs, der eine OpenGL-Implementierung enthält.
- `amdgpu-pro-oglp` (AUR) ist der proprietäre Treiber für AMD-GPUs.
# Gaming-Plattformen
## Steam
Steam ist eine beliebte Spielevertriebsplattform von Valve.
- Installieren Sie zur Installation einfach das Paket ```steam```^extra^.
## Proton
Eine Kompatibilitätsebene, die es Steam ermöglicht, Windows-Spiele unter Linux auszuführen.
Wir empfehlen die Installation von Proton mit Hilfe von **ProtonUp-Qt**.
## ProtonUp-Qt
Ein grafisches Dienstprogramm zum Verwalten und Installieren verschiedener Versionen von Proton auf Steam, mit dem Sie für jedes Spiel die beste Version auswählen können.
- zur Installation einfach installieren ```protonup-qt```^AUR^
## Proton-GE
Eine optimierte und erweiterte Version von Proton, die eine bessere Leistung zum Ausführen von Windows-Spielen unter Linux bietet.
Wir empfehlen die Installation von Proton mit Hilfe von **ProtonUp-Qt**.
## [GameMode](https://wiki.archlinux.org/title/Gamemode)
Ein Systemdienstprogramm, das temporäre Optimierungen anwendet, um die Spieleleistung unter Linux zu verbessern.
- zur Installation einfach installieren ```gamemode```^extra^ ```lib32-gamemode```^extra^ packages
## Wine-GE
Eine optimierte und erweiterte Version von Wine **(der Windows-Kompatibilitätsschicht für Linux)**, die auf das Ausführen von Windows-Spielen unter Linux zugeschnitten ist.
- zur Installation einfach installieren ```wine-ge-custom```^AUR^
## [Lutris](https://lutris.net/)
Eine All-in-One-Anwendung zum Installieren und Ausführen von Windows- und Linux-Spielen unter Linux, die Tools wie Wine-GE und Proton unterstützt.
- zur Installation einfach installieren ```lutris```^extra^
### Zusätzliche Tipps
- Prüfen Sie **[ProtonDB](https://www.protondb.com/)** auf Kompatibilitätsberichte und Tipps zum besseren Ausführen von Spielen.
- So legen Sie die in Steam für ein Spiel verwendete Proton-Version fest:
1. Klicken Sie mit der rechten Maustaste auf das Spiel in Ihrer Steam-Bibliothek und wählen Sie Eigenschaften.
2. Gehen Sie zur Registerkarte Kompatibilität.
3. Wählen Sie aus der Liste „Dieses Tool für Kompatibilität verwenden“ die gewünschte Proton-Version aus (z. B. Proton-GE).
- So aktivieren Sie den GameMode für ein bestimmtes Steam-Spiel:
1. Klicken Sie mit der rechten Maustaste auf das Spiel in Ihrer Steam-Bibliothek und wählen Sie „Eigenschaften“.
2. Gehen Sie zum Abschnitt „Startoptionen“.
3. Geben Sie in das Textfeld gamemoderun %command%“ ein.
> Mit dieser Anleitung sollten Sie in der Lage sein, die leistungsstarken Gaming-Tools von ParchLinux zu nutzen, um Spiele problemlos zu installieren und zu spielen. Weitere Informationen finden Sie in der offiziellen Dokumentation der einzelnen Tools.
>
{.is-success}

153
de/Gnome.md Normal file
View file

@ -0,0 +1,153 @@
---
title: GNOME-Desktopumgebung
description:
published: true
date: 2024-10-17T09:39:30.505Z
tags: gnome
editor: markdown
dateCreated: 2024-10-17T09:39:27.243Z
---
# Was ist GNOME?
> GNOME (/(ɡ)noʊm/) ist eine Desktopumgebung, die einfach und benutzerfreundlich sein soll. Sie wurde vom GNOME-Projekt entwickelt und besteht vollständig aus freier Open-Source-Software.
### Screenshot von Gnome in Parch Linux
![screenshot](https://github.com/parchlinux/Parch-iso-gnome/raw/main/image/screenshot.png)
## Von einem anderen Desktop zu Gnome wechseln
Um Gnome auf Parch Linux zu installieren, müssen Sie unser Metapaket installieren.
```bash
sudo pacman -S parch-gnome-meta
```
Dadurch würde eine minimale Gnome-Sitzung mit Parch-Anpassung auf Parch Linux installiert.
### Aktivieren des Display-Managers
Wenn Sie von KDE oder anderen Desktops wechseln (standardmäßig verwendet Parch SDDM in allen Editionen außer Gnome), müssen Sie Ihren alten Login-Manager deaktivieren und dann GDM aktivieren.
```bash
# Deaktivieren des alten Login-Managers (sddm)
sudo systemctl disable sddm
# Aktivieren GDM
sudo systemctl enable gdm
```
## Tips und Tricks
### Numlock beim GNOME-Start aktivieren
Sie müssen diesen Befehl im Terminal ausführen, um dieses Verhalten zu aktivieren:
```bash
gsettings set org.gnome.desktop.peripherals.keyboard numlock-state true
```
So merken Sie sich den letzten Zustand:
```bash
gsettings set org.gnome.desktop.peripherals.keyboard remember-numlock-state true
```
### Bestimmte URLs auf bestimmte Webbrowser umleiten
Dies zeigt, wie Chromium für bestimmte URL-Typen verwendet wird, während Firefox als Standardbrowser für alle anderen Aufgaben beibehalten wird.
Stellen Sie sicher, dass pcre installiert ist, um pcregrep zu verwenden.
Richten Sie benutzerdefiniertes xdg-open ein:
```
/usr/local/bin/xdg-open
```
```
#!/bin/bash
DOMAIN_LIST_FILE=~/'domains.txt'
OTHER_BROWSER='/usr/bin/chromium-browser'
BROWSER_OPTIONS='' # Optional, for command line options passed to browser
XDG_OPEN='/usr/bin/xdg-open'
DEFAULT_BROWSER='/usr/bin/firefox'
if echo "$1" | pcregrep -q '^https?://'; then
matching=0
while read domain; do
if echo "$1" | pcregrep -q "^https?://${domain}"; then
matching=1
break
fi
done < "$DOMAIN_LIST_FILE"
if [[ $matching -eq 1 ]]; then
"$OTHER_BROWSER" $BROWSER_OPTIONS ${*}
exit 0
fi
"$DEFAULT_BROWSER" ${*}
exit 0
else
"$XDG_OPEN" ${*}
fi
```
Konfigurieren Sie Domänen für die Weiterleitung zu Chromium:
```
$HOME/domains.txt
```
```
stackexchange.com
stackoverflow.com
superuser.com
www.youtube.com
github.com
```
Richten Sie xdg-open web als Desktopanwendung ein:
```
$HOME/.local/share/applications/xdg-open-web.desktop
```
```
[Desktop Entry]
Version=1.0
Name=xdg-open web
GenericName=Web Browser
Exec=xdg-open %u
Terminal=false
Type=Application
MimeType=text/html;text/xml;application/xhtml+xml;application/vnd.mozilla.xul+xml;text/mml;x-scheme-handler/http;x-scheme-handler/https;
StartupNotify=true
Categories=Network;WebBrowser;
Keywords=web;browser;internet;
Actions=new-window;new-private-window;
```
```
$ update-desktop-database $HOME/.local/share/applications/
```
Legen Sie xdg-open web als Standard-Webanwendung in den GNOME-Einstellungen fest: Gehen Sie zu GNOME-Einstellungen > Details > Standardanwendungen und legen Sie Web auf xdg-open web fest.
### Benutzerdefinierte GNOME-Sitzungen
Es ist möglich, benutzerdefinierte GNOME-Sitzungen zu erstellen, die den GNOME-Sitzungsmanager verwenden, aber unterschiedliche Komponentensätze starten (z. B. Openbox mit tint2 statt GNOME Shell).
Für eine benutzerdefinierte GNOME-Sitzung sind zwei Dateien erforderlich: eine Sitzungsdatei in ```/usr/share/gnome-session/sessions/``` der die zu startenden Komponenten definiert und einen Desktop-Eintrag in `/usr/share/xsessions` die vom Display-Manager gelesen wird. Nachfolgend finden Sie eine Beispiel-Sitzungsdatei:
```
/usr/share/gnome-session/sessions/gnome-openbox.session
```
```
[GNOME Session]
Name=GNOME Openbox
RequiredComponents=openbox;tint2;gnome-settings-daemon;
```
Und eine Beispiel-Desktopdatei:
```
/usr/share/xsessions/gnome-openbox.desktop
```
```
[Desktop Entry]
Name=GNOME Openbox
Exec=gnome-session --session=gnome-openbox
```

92
de/Package-management.md Normal file
View file

@ -0,0 +1,92 @@
---
title: Paketverwaltung
description:
published: true
date: 2024-05-31T16:52:02.409Z
tags:
editor: markdown
dateCreated: 2024-05-31T16:51:56.222Z
---
# Paketverwaltung in Parch Linux
## Paketverwaltung
Der Paketmanager in Parch Linux heißt Pacman.
Laut dem ArchLinux-Wiki:
>Der Paketmanager Pacman ist eines der wichtigsten Unterscheidungsmerkmale von Arch Linux. Er kombiniert ein einfaches binäres Paketformat mit einem benutzerfreundlichen Build-System. Das Ziel von Pacman ist es, die einfache Verwaltung von Paketen zu ermöglichen, egal ob sie aus den offiziellen Repositories oder den eigenen Builds des Benutzers stammen.
Pacman hält das System auf dem neuesten Stand, indem es Paketlisten mit dem Masterserver synchronisiert. Dieses Server/Client-Modell ermöglicht es dem Benutzer auch, Pakete mit einem einfachen Befehl herunterzuladen/zu installieren, komplett mit allen erforderlichen Abhängigkeiten.
Pacman ist in der Programmiersprache C geschrieben und verwendet das Tar-Format bsdtar(1) zum Verpacken.
## Wie funktioniert Pacman?
Hier ist ein kleiner Spickzettel, der Ihnen bei der Verwendung von Pacman hilft:
## Grundoperationen
| Aktion | Arch | Red Hat/Fedora | Debian/Ubuntu | SLES/openSUSE | Gentoo |
|--------|------|-----------------|----------------|-----------------|--------|
| Nach Paket(en) suchen | `pacman -Ss` | `dnf search` | `apt search` | `zypper search` oder `zypper se [-s]` | `emerge --search` (`-s`) oder `emerge --searchdesc` (`-S`) |
| Pakete nach Namen installieren | `pacman -S` | `dnf install` | `apt install` | `zypper install` oder `zypper in` | `emerge` |
| Quellpaket(e) abrufen und Abhängigkeiten erstellen | `makepkg -s PKGBUILD` | `dnf builddep` | `apt build-dep` | `zypper source-install` (`zypper si`) oder `zypper install -d` | `emerge`, oder ausdrücklich `emerge --with-bdeps` |
| Ziele drucken, ohne den Vorgang auszuführen | `pacman --print` (oder `-p`) | `dnf --setopt=tsflags=test` | `apt --simulate` (oder `-s`, `--dry-run`, `--just-print`) | `zypper --dry-run` | `emerge --pretend` (`-p`) |
| Bestätigungen umschalten | `pacman --confirm` oder `pacman --noconfirm` | `dnf --assumeyes` (`-y`) oder `dnf --assumeno` | `apt --yes` (`-y`) | `zypper --non-interactive` (`-n`) oder `zypper --no-confirm` (`-y`) | `emerge --ask` (`-a`) |
| Lokales Paket-Repository aktualisieren | `pacman -Sy` | `dnf check-update` oder `dnf makecache` oder `dnf upgrade` | `apt update` | `zypper refresh` oder `zypper ref` `[-s]` | `emerge --sync` |
| Upgrade-Pakete | `pacman -Syu` | `dnf upgrade` | `apt upgrade` | `zypper update` oder `zypper up` | `emerge -[a]uDN @world` |
| Upgrade-Pakete (komplexe Updates) | `pacman -Syu` | `dnf distro-sync` | `apt dist-upgrade` | `zypper dup` | `emerge -[a]uDN @world` |
| Entfernen Sie ein oder mehrere Pakete und Abhängigkeiten | `pacman -Rs` | `dnf remove` | `apt autoremove` | `zypper remove` or `zypper rm` | `emerge --depclean` (`-c`) |
| Pakete und Konfigurationsdateien entfernen | `pacman -Rn` | ? | `apt purge` | ? | n/a |
| Entfernen Sie Pakete, Abhängigkeiten und Konfigurationsdateien | `pacman -Rns` | ? | `apt autoremove --purge` | ? | n/a |
| Entfernen Sie nicht benötigte Abhängigkeiten | `pacman -Qdtq | pacman -Rs -` `` (`-Qdttq` für optionale Abhängigkeiten)| `dnf autoremove` | `apt autoremove` | `zypper rm -u` or `zypper packages --unneeded` | `emerge --depclean` (`-c`) |
| Entfernen Sie Pakete, die sich nicht in Repositories befinden | ```pacman -Rs $(pacman -Qmq)``` | `dnf repoquery --extras` | `aptitude purge '~o'` || ? |
| Installiertes Paket als ausdrücklich erforderlich markieren | `pacman -D --asexplicit` | `dnf mark install` | `apt-mark manual` | `zypper install --force` | `emerge --select` (`-w`) |
| Paket(e) als Abhängigkeit installieren | `pacman -S --asdeps` | `dnf install` dann `dnf mark remove` | `apt-mark auto` | n/a ([workaround](https://bugzilla.opensuse.org/show_bug.cgi?id=1175678)) | `emerge --oneshot` (`-1`) |
| Nur Paket(e) herunterladen | `pacman -Sw` | `dnf download` | `apt install --download-only` oder `apt download` | `zypper --download-only` | `emerge --fetchonly` (`-f`) |
| Lokale Caches bereinigen | `pacman -Sc` oder `pacman -Scc` | `dnf clean all` | `apt autoclean` oder `apt clean` | `zypper clean` | `eclean distfiles` |
| Starten einer Shell | | `dnf shell` | | `zypper shell` ||
## Abfragen bestimmter Pakete
| Aktion | Arch | Red Hat/Fedora | Debian/Ubuntu | SLES/openSUSE | Gentoo |
|--------|------|-----------------|----------------|-----------------|--------|
| Paketinformationen anzeigen | `pacman -Si` oder `pacman -Qi` | `dnf list` oder `dnf info` | `apt show` oder `apt-cache policy` | `zypper info` oder `zypper if` | `emerge -S`, `emerge -pv` oder `eix` |
| Lokale Paketinformationen anzeigen | `pacman -Qi` | `rpm -qi` / `dnf info installed` | `dpkg -s` oder `aptitude show` | `zypper --no-remote info` oder `rpm -qi` | `emerge -pv` oder `emerge -S` |
| Remote-Paketinformationen anzeigen | `pacman -Si` | `dnf info` | `apt-cache show` oder `aptitude show` | `zypper info` | `emerge -pv` and `emerge -S` oder `equery meta` |
| Lokale Paketdateien anzeigen | `pacman -Ql` | `rpm -ql` | `dpkg -L` | `rpm -ql` | `equery files` oder `qlist` |
| Remote-Paketdateien anzeigen | `pacman -Fl` | `dnf repoquery -l` oder `repoquery -l` | `apt-file list` || `pfl` |
| Abfragepaket, das Datei bereitstellt | `pacman -Qo` | `rpm -qf` (installed) oder `dnf provides` (alles) oder `repoquery -f` | `dpkg -S` oder `dlocate` | `rpm -qf` (installed) oder `zypper search -f` (alles) | `equery belongs` oder `qfile` |
| Auflisten der Dateien im Paket | `pacman -Ql` oder `pacman -Fl` | `dnf repoquery -l` | `dpkg-query -L` | `rpm -ql` | `equery files` oder `qlist` |
| Umgekehrte Angebote anzeigen | `pacman -F` | `dnf provides` | `apt-file search` | `zypper what-provides` oder `zypper wp` (exact)
oder `zypper se --provides` (fuzzy) | `equery belongs` (installed) or `pfl` |
| Paket nach Datei suchen | `pacman -F` | `dnf provides` | `apt-file search` oder `auto-apt` | `zypper search -f` | `equery belongs` oder `qfile` |
| Paket-Änderungsprotokoll anzeigen | `pacman -Qc` | `dnf changelog` | `apt-get changelog` | `rpm -q --changelog` | `equery changes -f` |
## AUR
> Das Arch User Repository (AUR) ist ein von der Community betriebenes Repository für Arch-Benutzer. Es enthält Paketbeschreibungen (PKGBUILDs), mit denen Sie ein Paket mit makepkg aus dem Quellcode kompilieren und dann über pacman installieren können. Das AUR wurde erstellt, um neue Pakete aus der Community zu organisieren und freizugeben und die Aufnahme beliebter Pakete in das zusätzliche Repository zu beschleunigen.
Eine große Anzahl neuer Pakete, die in die offiziellen Repositories aufgenommen werden, beginnen im AUR. Im AUR können Benutzer ihre eigenen Paket-Builds (PKGBUILD und zugehörige Dateien) beitragen. Die AUR-Community kann für Pakete im AUR stimmen. Wenn ein Paket populär genug wird vorausgesetzt, es verfügt über eine kompatible Lizenz und eine gute Verpackungstechnik kann es in das zusätzliche Repository aufgenommen werden (direkt zugänglich über pacman oder vom Arch-Build-System aus).
### AUR Manager
Parch Linux hat Paru, ebenso wie AUR Manager.
Die Verwendung von Paru ist genau wie die Verwendung von Pacman; mit der gleichen Syntax können Sie problemlos Pakete von AUR installieren.
#### Paru verwenden
Hier sind einige nützliche Paru-Befehle:
| Befehl | Beschreibung |
| --- | --- |
| `paru` | Aktualisieren Sie das gesamte System |
| `paru -Syu` | Aktualisieren Sie das gesamte System |
| `paru -S appname` | Installieren Sie das Programm von AUR |
| `paru appname` | Installieren Sie das Programm von AUR und wählen Sie aus der Liste |
| `paru -Sc` | Pacman- und Paru-Caches entfernen |
| `paru -Ss appname` | Nach einem Paket suchen |

35
de/Tips-and-tricks.md Normal file
View file

@ -0,0 +1,35 @@
---
title: Tips and tricks
description:
published: true
date: 2024-10-17T17:04:44.633Z
tags: tips, tricks
editor: markdown
dateCreated: 2024-10-17T17:04:41.168Z
---
# Tips and Tricks
## Die GPG-Signatur ist ungültig
Wenn Sie eine neue Anwendung herunterladen oder ein System aktualisieren und das Problem auftritt, dass die GPG-Signatur ungültig ist, sollten Sie Folgendes tun:
### Aktualisieren Sie das Archlinux-Keyring Paket
Wenn das Problem mit GPG von Archlinux-Paketen herrührt, müssen Sie dieses Paket neu installieren, um die neuesten Schlüssel zu erhalten.
```bash
sudo pacman -Sy
sudo pacman -S archlinux-keyring
```
## Die Größe des root im Live-System ist gering
Wenn Sie Parch Linux live verwenden müssen und mehr Speicherplatz für das Live-Root benötigen, müssen Sie diesen Befehl ausführen:
```bash
sudo mount -o remount,size=1G /run/archiso/cowspace
```
Der obige Befehl würde das root-Dateisystem auf 1G vergrößern. Wenn Sie mehr Platz benötigen, ändern Sie das 1G-Kommando in etwas anderes, zum Beispiel: 4G

View file

@ -0,0 +1,65 @@
---
title: Auswahl der richtigen Version
description:
published: true
date: 2024-10-17T09:18:42.880Z
tags:
editor: markdown
dateCreated: 2024-05-31T16:10:40.985Z
---
# Welche Version von Parch Linux ist die richtige für mich?
## Parch Linux Plasma Edition
### Was ist Plasma Desktop?
KDE Plasma ist eine funktionsreiche und hochgradig anpassbare Desktopumgebung, die ein modernes und intuitives Benutzererlebnis bietet. Es ist bekannt für seine Flexibilität, umfangreichen Anpassungsoptionen und eine breite Palette an Anwendungen und Tools.
![screenshot](https://github.com/parchlinux/parch-iso-plasma/raw/main/image/screenshot.png)
### Vorinstallierte Applications
| Name | Verwendung | Kategorie |
|--------------|-----------|------------|
| Tokodon | Ein Client zum Durchsuchen des Fediversums. | Sozial |
| Neochat | Ein Client zum Durchsuchen der [Matrix]. | Sozial |
| PlasmaTube | Ein Client zum Ansehen von Peertube und piped YouTube | Film & Musik |
| VLC | Ein in QT geschriebener Videoplayer | Film & Musik |
| Elisa | Ein einfacher und benutzerfreundlicher Musikplayer, geschrieben in CPP und Kirigami | Film & Musik |
| Firefox | Schneller, privater und sicherer Webbrowser | Web Browser |
| MarkNote | Machen Sie sich Notizen in Markdown | Produktivität |
## Parch Linux Gnome Edition
### Was ist Gnome Desktop?
GNOME ist eine benutzerfreundliche und moderne Desktopumgebung, die ein nahtloses und intuitives Benutzererlebnis bietet. Sie wurde mit Blick auf Einfachheit, Zugänglichkeit und Anpassungsfähigkeit entwickelt. GNOME bietet eine breite Palette an Funktionen und Anwendungen, darunter einen Dateimanager, einen Webbrowser, einen Texteditor und eine Vielzahl von Produktivitätstools.
![screenshot](https://github.com/parchlinux/Parch-iso-gnome/raw/main/image/screenshot.png)
### Vorinstallierte Applications in Gnome
| Name | Verwendung | Kategorie |
|--------------|-----------|------------|
| Tuba | Ein Client zum Durchsuchen des Fediversums. | Sozial |
| Fractal | Ein Client zum Durchsuchen der [Matrix]. | Sozial |
| PipeLine | Ein Client zum Ansehen von Peertube und piped YouTube | Film & Musik |
| Celluloid | Ein in GTK geschriebenes MPV-Frontend | Film & Musik |
| G4Music | Ein einfacher und benutzerfreundlicher Musikplayer, geschrieben in Vala und GTK | Film & Musik |
| Firefox | Schneller, privater und sicherer Webbrowser | Web Browser |
| Folio | Machen Sie sich Notizen in Markdown | Produktivität |
## Welches soll ich wählen?
| Gnome | Plasma |
|-----|------|
| Weniger Funktionen | Mehr Funktionen|
| Weniger Anpassung, aber einfacher | Mehr Anpassungsmöglichkeiten, aber steilere Lernkurve|
| Bessere GTK-Unterstützung | Bessere QT-Unterstützung|

113
de/debian-chroot.md Normal file
View file

@ -0,0 +1,113 @@
---
title: Debian Chroot im Parch Linux
description: Eine Anleitung zur Nutzung von Debian unter Parch Linux
published: true
date: 2024-10-18T07:33:28.930Z
tags: debian, parch
editor: markdown
dateCreated: 2024-10-18T07:33:24.452Z
---
# Was ist ein Chroot?
Die Linux-Utility chroot kann das Arbeitsverzeichnis eines Prozesses ändern und den Zugriff auf den Rest des Dateisystems einschränken.
## wie erhält man ein Debian-Chroot in ParchLinux?
1. Installieren Sie Debootstrap
```bash
sudo pacman -Sy
sudo pacman -S debootstrap
```
2. Erstellen Sie einen Ordner in /opt für Ihr neues Debian root
```bash
sudo mkdir /opt/debian
```
3. Legen Sie den Debootstrap-Speicherort fest und starten Sie das Debootstraping :D
```bash
DEBOOTSTRAP_DIR=/opt/debootstrap/usr/share/debootstrap /opt/debootstrap/usr/sbin/debootstrap --arch amd64 bookworm /opt/debian/ http://ftp.uk.debian.org/debian/
```
- **Hinweis**: Sie können die Debian-Version ändern, indem Sie den Bookworm in Ihren Versionscodenamen ändern. Sie finden Debian-Codenamen [hier](https://wiki.debian.org/DebianReleases#Production_Releases).
4. Mounten Sie die Verzeichnisse
```bash
mount -t proc proc /opt/debian/proc/
mount -t sysfs sys /opt/debian/sys/
mount -o bind /dev /opt/debian/dev/
mount -o bind /dev/pts /opt/debian/dev/pts/
```
5. Richten Sie die Repositories für Ihr Chroot-System ein
```bash
cat > /opt/debian/etc/apt/sources.list << 'EOF'
deb http://ftp.uk.debian.org/debian/ bookworm main non-free contrib
deb-src http://ftp.uk.debian.org/debian/ bookworm main non-free contrib
deb http://security.debian.org/ bookworm/updates main non-free contrib
deb-src http://security.debian.org/ bookworm/updates main non-free contrib
deb http://ftp.uk.debian.org/debian/ bookworm-updates main non-free contrib
deb-src http://ftp.uk.debian.org/debian/ bookworm-updates main non-free contrib
EOF
```
- **Hinweis**: Ändern Sie den Codenamen in Ihre installierte Version
6. Chroot zu Ihrem Debian
```bash
chroot /opt/debian /bin/bash
```
7. Aktualisieren Sie Debian und generieren Sie die Gebietsschemas neu:
```bash
apt-get update && apt-get dist-upgrade
apt-get install locales
dpkg-reconfigure locales
```
8. Fügen Sie einen Namen hinzu /etc/hosts
```bash
echo mywonderfulldebian >> /etc/hosts
```
## Optional
1. Einen neuen Benutzer zum Chroot hinzufügen
```bash
apt-get install curl sudo ncurses-term
groupadd sudo
useradd -m -G sudo -s /bin/bash parch
passwd parch
```
- **Hinweis**: Ersetzen Sie „parch“ durch Ihren Benutzernamen.
2. neuen Benutzer zu sudoers hinzufügen
```bash
cat > /etc/sudoers << 'EOF'
root ALL=(ALL) ALL
%sudo ALL=(ALL) ALL
EOF
```
3. Stellen Sie eine Verbindung zu Ihrem Benutzer her
```bash
sudo -iu parch
```
oder
```bash
su parch
```

13
de/home.md Normal file
View file

@ -0,0 +1,13 @@
---
title: Startseite
description: Willkommen im Parch Linux-Wiki!
published: true
date: 2024-05-28T08:21:49.123Z
tags:
editor: markdown
dateCreated: 2024-05-28T08:21:38.611Z
---
# Willkommen im Parch Linux-Wiki!
Dies ist das offizielle Wiki für Parch Linux.
Sie können **Lösungen** für Ihre Probleme finden und gleichzeitig etwas Neues lernen.

56
de/plasma.md Normal file
View file

@ -0,0 +1,56 @@
---
title: KDE Plasma
description:
published: true
date: 2024-10-17T10:15:38.437Z
tags: parchlinux, plasma, kde
editor: markdown
dateCreated: 2024-10-17T10:15:35.044Z
---
# KDE Plasma
## Was ist kde plasma?
KDE Plasma ist eine funktionsreiche und hochgradig anpassbare Desktopumgebung, die ein modernes und intuitives Benutzererlebnis bietet. Es ist bekannt für seine Flexibilität, umfangreichen Anpassungsoptionen und eine breite Palette an Anwendungen und Tools.
Parch Linux Plasma ist die **Flaggschiff** Version von Parch Linux.
![screenshot](https://raw.githubusercontent.com/parchlinux/parch-iso-plasma/main/image/screenshot.png)
## Installation
Sie können Plasma installieren, indem Sie Parch Linux Plasma installieren oder Ihren Desktop ändern.
Um den Desktop zu ändern, müssen Sie diese Pakete installieren:
```bash
sudo pacman -S plasma konsole kate dolphin sddm ark # for minimal installation
sudo pacman -S plasma konsole kate dolphin sddm ark plasmatube tokodon merkuro neochat marknote # for full ParchLinux plasma packages
```
>
> Wenn Sie von der neuesten Version von Gnome migrieren, denken Sie daran, `QT_QPA_PLATFORMTHEME=qt6ct` aus `/etc/envierment`
{.is-info}
## Tips and Tricks
### Einen regionalen Screenshot erstellen
Durch Drücken von <kbd>Meta</kbd> + <kbd>Umschalt</kbd> + <kbd>Druck</kbd> können Sie mit Spectacle einen Bildschirmbereich auswählen, um einen Screenshot zu erstellen.
### Ändern des Menüsymbols zum ParchLinux-Logo
Derzeit wenden wir das Parchlogo nicht standardmäßig auf das Anwendungsmenü an. Um es zu ändern, klicken Sie mit der rechten Maustaste auf das Menü und dann auf `Anwendungsmenü konfigurieren`. Wählen Sie dann parch-logo.svg von diesem Speicherort aus:
`/usr/share/pixmaps/parch-logo.svg`
### Firefox KDE-Dateiauswahl
Damit Firefox besser mit KDE zusammenarbeitet, können Sie entweder das Paket `firefox-kde-opensuse`^AUR^ installieren oder die Einstellung manuell ändern:
Um den KDE-Dateiwähler in Firefox 64 oder neuer zu verwenden, installieren Sie `xdg-desktop-portal` und `xdg-desktop-portal-kde` und setzen Sie dann `widget.use-xdg-desktop-portal.file-picker` in `about:config` auf 1.

114
debian-chroot.md Normal file
View file

@ -0,0 +1,114 @@
---
title: Debian Chroot in Parch Linux
description: A Guide to have debian under Parch Linux
published: true
date: 2024-04-05T10:42:59.452Z
tags: debian, parch
editor: markdown
dateCreated: 2024-04-05T10:37:55.039Z
---
# What is a Chroot?
The chroot Linux utility can modify the working root directory for a process, limiting access to the rest of the file system.
## how to have a Debian chroot inside ParchLinux?
1. Install Debootstrap
```bash
sudo pacman -Sy
sudo pacman -S debootstrap
```
2. Make a Folder inside /opt for your debian new root
```bash
sudo mkdir /opt/debian
```
3. Set Debootstrap location and start Debootstraping :D
```bash
DEBOOTSTRAP_DIR=/opt/debootstrap/usr/share/debootstrap /opt/debootstrap/usr/sbin/debootstrap --arch amd64 bookworm /opt/debian/ http://ftp.uk.debian.org/debian/
```
- **Note** : You can change the debian version by changing the bookworm to your version codename. You can find debian codenames [here](https://wiki.debian.org/DebianReleases#Production_Releases).
4. Mount the Directories
```bash
mount -t proc proc /opt/debian/proc/
mount -t sysfs sys /opt/debian/sys/
mount -o bind /dev /opt/debian/dev/
mount -o bind /dev/pts /opt/debian/dev/pts/
```
5. Setup the repositories for your chrooted system
```bash
cat > /opt/debian/etc/apt/sources.list << 'EOF'
deb http://ftp.uk.debian.org/debian/ bookworm main non-free contrib
deb-src http://ftp.uk.debian.org/debian/ bookworm main non-free contrib
deb http://security.debian.org/ bookworm/updates main non-free contrib
deb-src http://security.debian.org/ bookworm/updates main non-free contrib
deb http://ftp.uk.debian.org/debian/ bookworm-updates main non-free contrib
deb-src http://ftp.uk.debian.org/debian/ bookworm-updates main non-free contrib
EOF
```
- **Note** : Change the Codename to your installed Version
6. Chroot to your debian
```bash
chroot /opt/debian /bin/bash
```
7. Upgrade the Debian and regenerate the locales:
```bash
apt-get update && apt-get dist-upgrade
apt-get install locales
dpkg-reconfigure locales
```
8. Add a name to /etc/hosts
```bash
echo mywonderfulldebian >> /etc/hosts
```
## Optional
1. Add a new user to the chroot
```bash
apt-get install curl sudo ncurses-term
groupadd sudo
useradd -m -G sudo -s /bin/bash parch
passwd parch
```
- **note** : Replace parch with your username
2. add new user to sudoers
```bash
cat > /etc/sudoers << 'EOF'
root ALL=(ALL) ALL
%sudo ALL=(ALL) ALL
EOF
```
3. connect to your user
```bash
sudo -iu parch
```
or
```bash
su parch
```

133
distrobox.md Normal file
View file

@ -0,0 +1,133 @@
---
title: Distrobox
description:
published: true
date: 2024-07-26T09:55:03.789Z
tags: distrobox, podman, docker
editor: markdown
dateCreated: 2024-07-26T09:52:59.311Z
---
# Distrobox
> Distrobox is a container wrapping layer that allows the user to install containerised versions of Linux that are different to the host while providing tight integration with the host allowing the use of binaries designed for one distribution to run on another.
Distrobox itself is not a container manager and relies on Podman or [Docker](https://wiki.parchlinux.com/en/docker) to create containers
From the Distrobox documentation:
> Use any Linux distribution inside your terminal. Enable both backward and forward compatibility with software and freedom to use whatever distribution youre more comfortable with. Distrobox uses Podman or Docker to create containers using the Linux distribution of your choice. The created container will be tightly integrated with the host, allowing sharing of the HOME directory of the user, external storage, external USB devices and graphical apps (X11/Wayland), and audio.
## Security implications
The main goal of Distrobox is not focused on sandboxing the containers from the host and the containers that are running inside distrobox would have full access to your home folder as well as some other locations.
It is recommended to use **Podman** instead of **Docker** since by default docker would run containers as root and rootful containers **will have unrestricted access to your host filesystem**
## Installation
### With root access
first you need install either podman or docker to begin.
then install ```distrobox``` or ```distrobox-git``` from aur using paru.
### Without root access
It is possible to install Distrobox into your home folder if you don't have root access to the system or if you are using an immutable distro. Doing so requires the use of a curl-to-sh pipe which is an unsupported installation method due to it posing a security risk.
You can find instructions on the [Distrobox documentation page](https://distrobox.privatedns.org/#curl-or-wget)
## Usage
> Note:
> - Throughout the following section ```name``` is a variable and can be whatever you want. In all cases replace ```name``` with the actual name you choose
> - For the full list of supported options in any sub category use ```--help```, for example to see all creation options use ```distrobox create --help```
> - A full list of supported distros along with their image names can be found at https://distrobox.it/compatibility/#containers-distros
> - For more advanced usage techniques please see the Distrobox Documentation page at https://distrobox.it/usage/usage/
To create a new container run the following:
```bash
distrobox create -n name
```
To List installed containers:
```bash
distrobox list
```
To intract with an installed container:
```bash
distrobox enter name
```
or you can run a command directly:
```bash
distrobox enter name -- command
```
To stop a running container run the following:
```
distrobox stop name
```
To delete a container run the following:
```
distrobox rm name
```
To install a specific distro into a container run the following (in this example its Ubuntu):
```
distrobox create --image ubuntu:22.04
```
Installations can be fully customised as follows (in this example its a container called test running Gentoo with root access):
```
distrobox create -i docker.io/gentoo/stage3:latest -n test --root
```
If you need your container to have root access to the host then it is recommended that you use the ```--root``` flag over ```sudo distrobox```
## Configuration
It is possible to configure Distrobox in two ways, either with a configuration file or by using environment variables.
### Configuration files
Distrobox checks the following locations for config files, from least important to most important:
/usr/share/distrobox/distrobox.conf
/usr/etc/distrobox/distrobox.conf
/etc/distrobox/distrobox.conf
~/.config/distrobox/distrobox.conf
~/.distroboxrc
An example config file is as follows:
```
container_always_pull="1"
container_generate_entry=0
container_manager="docker"
container_image_default="registry.opensuse.org/opensuse/toolbox:latest"
container_name_default="test-name-1"
container_user_custom_home="$HOME/.local/share/container-home-test"
container_init_hook="~/.local/distrobox/a_custom_default_init_hook.sh"
container_pre_init_hook="~/a_custom_default_pre_init_hook.sh"
non_interactive="1"
skip_workdir="0"
```
### Environment variables
The following variables are available and should be set using per user variables:
```
DBX_CONTAINER_ALWAYS_PULL
DBX_CONTAINER_CUSTOM_HOME
DBX_CONTAINER_IMAGE
DBX_CONTAINER_MANAGER
DBX_CONTAINER_NAME
DBX_CONTAINER_ENTRY
DBX_NON_INTERACTIVE
DBX_SKIP_WORKDIR
```

414
fa/Docker.md Normal file
View file

@ -0,0 +1,414 @@
---
title: داکر
description: داکر یک ابزار برای ایزوله سازی (Containerization) برای توسعه تمیز تر و راحت برای توسعه دهندگان است
published: true
date: 2024-08-12T07:20:23.121Z
tags: داکر, container
editor: markdown
dateCreated: 2024-07-23T16:21:30.996Z
---
# توضیحات
docker ابزاری برای ایزوله سازی (Containerization) است که امکان اشتراک گذاری محیط توسعه را به صورت container در هر سیستم عاملی می دهد, این کار موجب تسریع زمان توسعه و اشتراک گذاری محیط بین اعضای تیم می شود, همچنین از تداخل وابستگی ها جلوگیری می کند، چرا که تمام وابستگی ها در container و به صورت ایزوله نگه داری میشود.
# تاریخچه
قبل از ایجاد مفهموم container و ایزوله سازی محیط, مجازی سازی (Virtualization) یکی از اصلی ترین راهکار ها برای جدا کردن محیط توسعه از سیستم میزبان بود, کاربر با اختصاص دادن cpu ,memory و hard space تایین می کرد چه مقدار منابع از سیستم میزبان به سیستم مجازی تعلق دارد, اما این راهکار چندان مناسب نبود چرا که مقدار قابل توجهی از منابع به سیستم عامل مجازی تعلق میگرفت و سرعت پردازش نسبت به سیستم میزبان کند تر بود.
اما با ورود مفهوم container, موجب شد که ایزوله سازی و جدا کردن محیط های مختلف به صورت کم هزینه تر و با منابع کمتری صورت بپذیرد.
docker یکی از ابزار هایی است که میتوان برای ساخت و مدیریت container و ... از آن استفاده کرد, ممکن است نیاز داشته باشد که محیط توسعه/محصول خودتان را با دیگر اعضا به اشتراک بگذارید, docker این امکان را فراهم می کند تا با اشتراک گذاری فایل اسکلت container خود (image) این کار را تسریع کنید, همچنین افراد دیگر نگرانی جهت بر طرف کردن وابستگی ها ندارند چرا که تمام انها از قبل حل شده است.
# [نصب و راه اندازی](https://itsfoss.com/install-docker-arch-linux/)
سایت مرجع [docker](https://docs.docker.com/engine/install/) اموزش کاملی را جهت نصب در سیستم های لینوکسی پوشش داده است اما توزیع های مبتبی بر ارچ به صورت رسمی پوشش داده نشده است و نصب آن به صورت unstable است.
1- ترمینال را باز کنید و با استفاده از مدیر بسته docker را نصب کنید
```
sudo pacman -S docker
```
> اگر با خطای ```docker not found``` مواجه شدید مطمئن شوید مخازن خود را بروزرسانی کرده اید با دستور ```sudo pacman -Syu``` می توانید از بروز بودن مخازن خود اطمینان حاصل کنید
2- اگر از systemd به عنوان init استفاده می کنید با دستور زیر سرویس docker را فعال کنید:
```
sudo systemctl enable --now docker.service
```
3- در این مرحله باید نام کاربری خودتان را به گروه docker اضافه کنید:
> برای اعمال تغییرات یکبار از سیستم logout کنید یا از دستور ```newgrp docker``` استفاده کنید.
```
sudo usermod -aG docker $USER
```
4- حالا می توانید با run کردن hello-world که یک image است از درست کار کردن docker اطمینان حاصل کنید.
```
docker run hello-world
```
دستور run همانطور که از اسم آن پیداست برای اجرا کردن image ها می باشد, image ها اسلکت هایی هستند که container ها از آنها ساخته میشوند, مجموعه از فایل ها و پیکربندی هایی از پیش تعریف شده که container بر اساس آنها ساخته میشود.
برای لیست کردن image های موجود در سیستم خودتان میتوانید از ```docker images``` استفاده کنید
برای لیست کردن container های فعال میتوانید از ```docker ps``` استفاده کنید.
# [Docker hub](https://hub.docker.com/)
[Docker hub](https://hub.docker.com/) به عنوان مخزن پیشفرض docker برای دانلود و اپلود image ها مورد استفاده قرار می گیرد.
به عنوان مثال ممکن است بخواهید از nginx به عنوان webserver خود استفاده کنید, میتوانید image nginx را از docker hub دریافت کنید و از روی آن یک container ایجاد کنید.
1- با استفاده از ```docker login``` به حساب کاربری خود وارد شوید.
> اگر حساب کاربری ندارید, یکی [ایجاد](https://app.docker.com/signup?) کنید
2- میتوانید با استفاده از ```docker pull nginx``` اخرین ورژن nginx را از docker hub دریافت کنید.
> متاسفانه docker hub در ایران تحریم است, در صورتی که با خطای 403 یا connection time out مواجه شدید, به احتمال زیاد مشکل از تحریم ها می باشد, میتوانید با خواندن [رفع تحریم](#رفع-تحریم) این مشکل را حل کنید.
> وب سرور nginx در docker hub [مستندات کاملی](https://wiki.parchlinux.com/fa/Docker) را درباره نحوه کار با image و container جمع اوری کرده است.
بعد از اتمام دانلود image میتوانید با استفاده از دستور ```run``` یک container برای nginx ایجاد کنید
```
docker run --name some-nginx -p 8080:80 -v /some/content:/usr/share/nginx/html:ro -d nginx
```
> اگر از mirror های دیگری مانند focker.ir برای دانلود image استفاده کرده اید باید از نام focker.ir/nginx به جای nginx استفاده کنید
```
docker run --name some-nginx -p 8080:80 -v /some/content:/usr/share/nginx/html:ro -d focker.ir/nginx
```
1- پرچم ```name--``` برای اختصاص یک نام به container استفاده میشود که در این مثال some-nginx می باشد
2- پرچم ```v-``` یا ```volume--``` برای اشتراک گذاری یک (مسیر از سیستم میزبان) با (یک مسیر در کانتینر) استفاده میشود
> در این مثال مسیر ```/some/content``` از سیستم میزبان (اصلی) با ```/usr/share/nginx/html``` در container مشترک شده است, به عنوان مثال اگر فایلی به نام name.txt را در سیستم میزبان (اصلی) در مسیر ```/some/content``` ایجاد کنید, بعد از ورود به container می توانید همان فایل را در ادرس ```/usr/share/nginx/html``` مشاهده کنید.
> در اخرین بخش مقدار volume که با ```:``` جدا شده اند, ```ro``` به معنا تنها خواندی (readonly) می باشد, اگر مقدار آن را rw قرار دهید خواندنی و نوشتنی (read and write) خواهد بود.
4- پرچم ```p-``` یا ```port--``` یک پورت از سیستم میزبان را به یک پورت از container متصل می کند
> در این مثال پورت ```8080``` از سیستم میزبان (اصلی) به پورت ```80``` container متصل شده است.
3- پرچم ```d-``` به معنای اجرای پروسه در background می باشد.
# رفع تحریم
برای رفع تحریم می توان از راهکار های زیر استفاده کرد:
1- استفاده از dns
2- استفاده از mirror های دیگر
3- استفاده از ابزار های proxy client همانند [hiddify](https://hiddify.com/) و [nekoray](https://github.com/MatsuriDayo/nekoray) ...
## استفاده از mirror های دیگر
ساده ترین روش برای دور زدن تحریم ها می باشد با استفاده از مخازن دیگر اقدام به دانلود image ها می کنید (همانند focker.ir و ابراروان)
ابراروان یک [مستند](https://www.arvancloud.ir/fa/dev/docker) جامع در این باز منتشر کرده است
اما به طور خلاصه میتوانید تنها با اضافه کردن ادرس دامین /docker.arvancloud.ir به اول اسم image از مخازن ابراروان برای دانلود image استفاده کنید:
```
docker pull docker.arvancloud.ir/<ImageName>
```
همچنین برای /focker.ir نیز به همین صورت است:
```
docker pull focker.ir/<ImageName>
```
## استفاده از dns
تعدادی dns داخلی به جهت رفع تحریم ها در دسترس است که معروف ترین انها [shecan](https://shecan.ir/), [403](https://403.online/) و [begzar](https://begzar.ir/) است.
### begzar
```
etc/resolv.conf/#
nameserver 185.55.226.26
nameserver 185.55.225.25
```
### 403
```
etc/resolv.conf/#
nameserver 10.202.10.202
nameserver 10.202.10.102
```
### shecan
```
etc/resolv.conf/#
nameserver 178.22.122.100
nameserver 185.51.200.2
```
# [docker compose](https://docs.docker.com/compose/)
docker compose یکی از قدرتمند ترین دستور های docker است که امکان می دهد در صورت استفاده از چند container برای یک هدف مشترک, config های انها را در یک فایل yaml تعریف کنید و هر بار مجبور به تایپ کردن آنها در ترمینال یا نوشتن دستی آنها در script نباشید و در نهایت با اجرا تنها یک دستور تمامی container ها را اجرا کنید.
# ابزار ها
## پرچم ها
داکر مجوعه از پرچم ها را ارائه می دهد:
### --help
نحوه استفاده از docker و دستورات را نمایش می دهد.
### -D, --debug=true|false
حالت دیباگ را فعال با غیر فعال می کند
### -H, --host=[unix:///var/run/docker.sock]
ادرس socket را برای سرویس docker مشخص می کند
### -l, --log-level=debug|info|warn|error|fatal
سطح لاگ را مشخص می کند (به صورت پیشفرض info است)
### --tls=true|false
استفاده از پکت ها tls را مشخص میکند (پیشفرض false)
### --tlscacert=~/.docker/ca.pem
بررسی می کند certs ها حتما توسط CA مشخص شده امضا شده باشد
### --tlscert=~/.docker/cert.pem
نحوه استفاده از داکر و مجوعه ای از دستورات را نمایش می دهد.
### --tlskey=~/.docker/key.pem
ادرس کلید tls را برای CA مشخض می کند
### --tlsverify=true|false
از tls استفاده می کند و کنترول از راه دور را تایید می کند
### -v, --version=true|false
نسخه فعلی docker را نمایش می دهد
## دستورات
با استفاده از ```docker --help``` می توانید لیست دستورات را بررسی کنید
### run
اجرای یک container جدید از یک تصویر
```
docker run hello-world
```
### exec
اجرای دستورات در یک container در حال اجرا
```
docker exec -it my_container bash
```
### ps
نمایش container های در حال اجرا
```
docker ps
```
### build
ساخت تصویر Docker از فایل Dockerfile
```
docker build -t my_image .
```
### pull
دانلود image از Docker Hub
```
docker pull nginx
```
### push
آپلود image به Docker Hub
```
docker push focker.ir/my_image
```
### images
نمایش لیست image های موجود
```
docker images
```
### login
ورود به Docker Hub
```
docker login
```
### logout
خروج از Docker Hub
```
docker logout
```
### search
جستجوی image در Docker Hub
```
docker search redis
```
### version
نمایش نسخه Docker
```
docker version
```
### info
نمایش اطلاعات سیستم Docker
```
docker info
```
### attach
اتصال به یک container در حال اجرا
```
docker attach my_container
```
### commit
ساخت یک image از یک container در حال اجرا
```
docker commit my_container my_image
```
### cp
کپی فایل ها بین هاست ( سیستم میزبان) و container
```
docker cp my_container:/path/in/container /path/on/host
```
### create
ساخت یک container جدید
```
docker create --name my_container ubuntu
```
### diff
نمایش تغییرات فایل های container
```
docker diff my_container
```
### events
نمایش رویدادهای Docker
```
docker events
```
### export
خروجی گرفتن از filesystem یک container به صورت فایل tar
```
docker export my_container -o my_container.tar
```
### history
نمایش تاریخچه یک image
```
docker history ubuntu
```
### import
وارد کردن filesystem به عنوان image
```
docker import my_container.tar my_image
```
### inspect
نمایش جزئیات یک container یا image
```
docker inspect my_container
```
### kill
متوقف کردن یک container
```
docker kill my_container
```
### load
بارگذاری image از فایل tar
```
docker load -i my_image.tar
```
### logs
نمایش لاگ های یک container
```
docker logs my_container
```
### pause
متوقف کردن موقت اجرای یک container
```
docker pause my_container
```
### port
نمایش نقشه برداری پورت container
```
docker port my_container
```
### rename
تغییر نام یک container
```
docker rename my_container new_container_name
```
### restart
ریستارت کردن یک container
```
docker restart my_container
```
### rm
حذف یک container
```
docker rm my_container
```
### rmi
حذف یک image
```
docker rmi my_image
```
### save
ذخیره یک image به صورت فایل tar
```
docker save -o my_image.tar my_image
```
### start
شروع به کار یک container متوقف شده
```
docker start my_container
```
### stats
نمایش اطلاعات آماری container ها
```
docker stats my_container
```
### stop
متوقف کردن اجرای یک container
```
docker stop my_container
```
### tag
ایجاد یک tag برای یک image
```
docker tag my_image my_repo/my_image:tag
```
### top
نمایش فرآیندهای در حال اجرای یک container
```
docker top my_container
```
### unpause
ادامه اجرای یک container متوقف شده
```
docker unpause my_container
```
### update
به‌روزرسانی تنظیمات یک container
```
docker update --cpus=2 my_container
```
### wait
منتظر ماندن تا پایان اجرای یک container
```
docker wait my_container
```

145
fa/Gaming.html Normal file
View file

@ -0,0 +1,145 @@
<!--
title: بازی کردن در پارچ لینوکس
description: راهنمای ساده درباره تجربه بازی ها در پارچ لینوکس
published: true
date: 2024-11-22T14:22:20.751Z
tags: گیمینگ, بازی, لینوکس, پارچ لینوکس
editor: ckeditor
dateCreated: 2024-10-23T12:54:37.951Z
-->
<h1>بازی کردن در پارچ لینوکس</h1>
<p>مطابق ویکی آرچ لینوکس:</p>
<blockquote>
<p>لینوکس مدت ها به صورت “غیر رسمی”به عنوان یک سکو بازی شناخته شده است؛حمایت و مخاطبانی که به آن اختصاص داده می‌شود، برای بیشتر شرکت‌های بازی‌سازی اولویت اصلی نیست. از سال 2021 به بعد،تغییرات این وضعیت شتاب بیشتری گرفته تا جایی که شرکت Valve، گروه codewars و جامعه کاربران پیشرفت های فوق العاده ای را در این اکوسیستم ایجاد کرده اند تا این سکو را به عنوان یک گزینه واقعی برای بازی تبدیل کنند.</p>
<p>وقتی صحبت از بازی میشود،معمولا ذهن بیشتر کاربران به سمت بازی های پرطرفدار AAA میرود که معمولا بصورت انحصاری برای مایکروسافت ویندوز نوشته میشوند که این موضوع قابل درک اما تنها گزینه موجود نیست.لطفا به بخش های #game environment و #getting games در پایین صفحه مراجعه کنید، جایی که میتوانید نرم افزارهایی برای اجرا بازی های دیگر پلتفرم ها پیدا کنید.</p>
<p>اما اگر مصمم هستید که بازی های نوشته شده برای مایکروسافت ویندوز را روی لینوکس اجرا کنید،باید از رویکردها، ابزارها و طرز فکرهای متفاوتی استفاده کنید؛ درک عمیق تر از ساختار داخلی سیستم ها و فراهم کردن جایگزین‌های کاربردی لازم خواهد بود.</p>
</blockquote>
<h1>درایورها</h1>
<p>برای بهبود کیفیت تجربه بازی در پارچ لینوکس نیازمند نصب برخی درایورها هستید.</p>
<h2><a href="https://wiki.archlinux.org/title/Intel_graphics">Intel graphics</a></h2>
<p>برای سخت افزارهای نسل 3 و به بعد آنها که از intel GPU استفاده میکنند بسته های <code>mesa</code><sup>extra</sup> و <code>lib32-mesa</code> <sup>multilib</sup> را نصب کنید. همچنین برای سخت افزارهای نسل دو الی یازده بسته های <code>mesa-amber</code><sup>extra</sup> &nbsp;و <code>lib32-mesa-amber</code><sup>multilib</sup> را نصب کنید.</p>
<p>بسته &nbsp;<code>xf86-video-intel</code><sup>extra</sup> درایور قدیمی DDX اینتل را برای سخت افزارهای نسل 2 تا 9 را آماده میکند. <i>این بسته بصورت کلی توصیه نمیشود</i></p>
<h2><a href="https://wiki.archlinux.org/title/Vulkan">vulkan</a></h2>
<p>در این بخش دستورالعمل هایی برای نصب درایورهای Vulkan برای کارت گرافیک های اینتل و AMD آورده شده:</p>
<h3>برای کارت گرافیک های اینتل</h3>
<p>برای پشتیبانی از Vulkan(Haswell و نسل‌های جدیدتر؛ پشتیبانی برای تراشه‌های قدیمی‌تر ناقص یا وجود ندارد)، بسته <code>vulkan-intel</code><sup>extra</sup> را نصب کنید.</p>
<p>برای پشتیبانی در سیستم های 32بیتی بسته <code>lib32-vulkan-intel</code><sup>multilib</sup> را نصب کنید.</p>
<h3>برای کارت گرافیک های انویدیا</h3>
<p>برای کارت گرافیک های انویدیا، دو پیاده سازی در دسترس وجود دارد:</p>
<h4>درایورهای اختصاصی</h4>
<ul>
<li><code>nvidia-utils</code><sup>extra</sup> (یا <code>lib32-nvidia-utils</code><sup>multilib</sup> برای پشتیبانی سیستم های 32بیتی)</li>
<li>این درایور اختصاصی توسط انویدیا ارائه شده که شامل پیاده سازی OpenGL نیز میباشد.</li>
</ul>
<h4>درایورهای متن-باز</h4>
<ul>
<li><code>vulkan-nouveau</code><sup>extra</sup> (یا <code>lib32-vulkan-nouveau</code><sup>multilib</sup> برای سیستم های 32بیتی)</li>
<li>این درایور متن-باز NVK است که بخشی از پروژه Mesa میباشد و پیاده سازی و امکان پیاده سازی Vulkan برای کارت گرافیک های انویدیا را فراهم میکند.</li>
</ul>
<h3>برای کارت گرافیک های AMD</h3>
<p>Vulkan دو گزینه برای درایور AMD ارائه می‌دهد:</p>
<ol>
<li><strong>vulkan-radeon</strong></li>
</ol>
<p>RADV ((بخشی از پروژه Mesa))</p>
<p>از طریق نصب بسته <code>vulkan-radeon</code><sup>extra</sup> قابل دسترسی است.</p>
<ol>
<li><strong>amdvlk</strong></li>
</ol>
<p>AMDVLK Open ((توسط AMD نگهداری میشود))</p>
<p>از طریق نصب بسته <code>amdvlk</code><sup>extra</sup> قابل دسترسی است.</p>
<p>علاوه بر اینها، برای پشتیبانی از برنامه‌های 32 بیتی، میتوانید بسته های مربوطه lib32 را نصب کنید:</p>
<ul>
<li><code>lib32-vulkan-radeon</code><sup>multilib</sup> برای <strong>vulkan-radeon</strong></li>
<li><code>lib32-amdvlk</code><sup>multilib</sup> برای <strong>amdvlk</strong></li>
</ul>
<p>پس از نصب درایور Vulkan مناسب، سیستم شما باید بتواند برنامه ها و بازی های مبتنی بر Vulkan را بدون مشکل اجرا کند</p>
<blockquote>
<h2><a href="https://wiki.archlinux.org/title/AMDGPU">AMDGPU</a></h2>
</blockquote>
<blockquote>
<h2><a href="https://wiki.archlinux.org/title/NVIDIA">Nvidia</a></h2>
</blockquote>
<h2><a href="https://mesa3d.org/">Mesa</a></h2>
<p>Mesa یک پیاده‌سازی متن‌-باز از OpenGL است که بصورت مداوم بروزرسانی می‌شود تا از جدیدترین مشخصات OpenGL پشتیبانی کند. این پروژه مجموعه‌ای از درایورهای متن‌-باز برای کارت‌ گرافیک های اینتل، AMD((که قبلاً به نام ATI شناخته می‌شد)) و انویدیا ارائه می‌دهد. همچنین، Mesa همچنین نرم‌افزاری مانند llvmpipe نیز ارائه می‌کند.</p>
<p>دو بسته Mesa وجود دارد که هریک مجموعه ای مجزا از درایورها را ارائه می‌دهند:</p>
<h3>&nbsp;mesa</h3>
<p><code>mesa</code> یک بسته بروز از Mesa که شامل اکثر درایورهای مدرن برای سخت‌افزارهای جدیدتر می‌باشد:</p>
<ul>
<li><code>r300</code>: برای کارت گرافیک های Radeon R300، R400 و R500 شرکت AMD.</li>
<li><code>r600</code>: برای کارت‌ گرافیک های Radeon R600 تا Northern Islands شرکت AMD. بصورت رسمی توسط AMD پشتیبانی می‌شود.</li>
<li><code>radeonsi</code>: برای کارت‌ گرافیک های Southern Island و نسل‌های جدیدتر AMD. بصورت رسمی توسط AMD پشتیبانی می‌شود.</li>
<li><code>nouveau</code>: درایور متن-باز برای کارت گرافیک های انویدیا.</li>
<li><code>virtio_gpu</code>: درایور GPU مجازی برای virtio که می‌توان با ماشین مجازی های مبتنی بر QEMU (مثل KVM یا Xen) استفاده کرد.</li>
<li><code>vmwgfx</code>: برای GPU های مجازی VMware.</li>
<li><code>i915</code>: برای سخت افزار نسل 3 اینتل.</li>
<li><code>crocus</code>: برای سخت افزارهای نسل 4 الی 7 اینتل.</li>
<li><code>iris</code>: برای سخت افزارهای نسل 8 به بعد اینتل. بصورت رسمی توسط اینتل پشتیبانی میشود.</li>
<li><code>zink</code>: یک درایور Gallium که OpenGL را بر روی Vulkan اجرا میکند</li>
<li><code>d3d12</code>: برای پشتیبانی از OpenGL نسخه 3.3 در دستگاه‌هایی که تنها از D3D12 پشتیبانی می‌کنند ((مانند WSL)).</li>
<li><code>softpipe</code>: یک rasterizer نرم افزاری و درایور مرجع Gallium.</li>
<li><code>llvmpipe</code>: یک rasterizer نرم‌افزاری که از LLVM برای تولید کد JIT برای x86 استفاده می‌کند و مولتی-ترد((چند رشته ای)) است.</li>
</ul>
<h3>mesa-amber</h3>
<p><code>mesa-amber</code> &nbsp;بسته قدیمی Mesa است که شامل درایورهای قدیمی ((غیر از Gallium3D)) برای سخت‌افزارهای قدیمی می‌باشد:</p>
<ul>
<li><code>i830</code>: برای سخت‌افزار نسل 2 اینتل. از همان باینری درایور<code>i965</code>استفاده می‌کند.</li>
<li><code>i915</code>: برای سخت‌افزار نسل 3 اینتل. از همان باینری درایور<code>i965</code>استفاده می‌کند.</li>
<li><code>i965</code>: برای سخت‌افزار نسل 4 الی 11 اینتل. بصورت رسمی توسط اینتل پشتیبانی می‌شود.</li>
<li><code>radeon</code>: برای کارت‌ گرافیک های Radeon R100 شرکت AMD. از همان باینری درایور<code>r200</code>استفاده می‌کند.</li>
<li><code>r200</code>: برای کارت‌ گرافیک های Radeon R200 شرکت AMD.</li>
<li><code>nouveau_vieux</code>: برای کارت‌ گرافیک های NVIDIA NV04 (Fahrenheit) تا NV20 (Kelvin).</li>
<li><code>swrast</code>: یک rasterizer نرم‌افزاری قدیمی.</li>
</ul>
<p><strong>توجه</strong>: هنگام استفاده از Mesa، درایور مناسب بصورت خودکار انتخاب می‌شود، بنابراین پس از نصب بسته نیازی به تنظیمات اضافی نخواهد بود.</p>
<h1>سکو های گیمینگ</h1>
<h2>Steam</h2>
<p>استیم یک سکو محبوب توزیع بازی که توسط شرکت Valve طراحی شده.</p>
<ul>
<li>برای نصب آن، کافیست بسته <code>steam</code><sup>extra</sup>را نصب کنید.</li>
</ul>
<h2>Proton</h2>
<p>پروتون یک لایه سازگار است که به استیم اجازه میدهدبازی های ویندوزی را بر روی لینوکس اجرا کند.</p>
<p>ما توصیه میکنیم که پروتون را به کمک <strong>ProtonUp-Qt</strong> نصب کنید.</p>
<h2>ProtonUp-Qt</h2>
<p>یک ابزار گرافیکی برای مدیریت و نصب نسخه‌های مختلف پروتون بر روی استیم که به شما اجازه می‌دهد بهترین نسخه را برای هر بازی انتخاب کنید.</p>
<ul>
<li>برای نصب کافیست بسته <code>protonup-qt</code><sup>AUR</sup> را نصب کنید.</li>
</ul>
<h2>Proton-GE</h2>
<p>یک نسخه بهینه و توسعه یافته از پروتون که عملکرد بهتری برای اجرای بازی های ویندوزی بر روی لینوکس ارائه می‌دهد.</p>
<p>ما توصیه میکنیم که پروتون را به کمک <strong>ProtonUp-Qt</strong> نصب کنید.</p>
<h2>Wine-GE</h2>
<p>یک نسخه بهینه‌ و توسعه‌ یافته از Wine ((لایه سازگاری ویندوز برای لینوکس)) که بصورت ویژه برای اجرای بازی‌های ویندوزی روی لینوکس طراحی شده است.</p>
<ul>
<li>برای نصب کافیست پکیج <code>wine-ge-custom</code><sup>AUR</sup>را نصب کنید.</li>
</ul>
<h2><a href="https://wiki.archlinux.org/title/Gamemode">GameMode</a></h2>
<p>یک ابزار سیستمی که بصورت موقت بهینه سازی هایی را برای بهبود عملکرد بازی ها روی لینوکس اعمال میکند.</p>
<ul>
<li>برای نصب کافیست بسته های <code>gamemode</code><sup>extra</sup> &nbsp;و <code>lib32-gamemode</code><sup>extra</sup> &nbsp;را نصب کنید.</li>
</ul>
<h2><a href="https://lutris.net/">Lutris</a></h2>
<p>یک برنامه همه کاره و چند منظوره برای نصب و اجرای بازی‌های ویندوزی و لینوکسی روی لینوکس که از ابزارهایی مانند Wine-GE و پروتون پشتیبانی می‌کند.</p>
<h3>نکات اضافی</h3>
<ul>
<li><a href="https://www.protondb.com/"><strong>ProtonDB</strong></a> را برای گزارش‌های سازگاری و نکات بهبود اجرای بازی‌ها بررسی کنید.</li>
<li>برای تنظیم نسخه پروتون مورد استفاده در استیم برای یک بازی:</li>
</ul>
<ol>
<li>روی بازی در کتابخانه استیم خود راست-کلیک کرده و گزینه “Properties” را انتخاب کنید.</li>
<li>وارد تب "Compatibility" شوید.</li>
<li>از لیست "Use this tool for compatibility"، نسخه پروتون مورد نظر خود را انتخاب کنید ((مثلا Proton-GE)).</li>
</ol>
<ul>
<li>برای فعال کردن گیم مود برای یک بازی خاص در استیم:</li>
</ul>
<ol>
<li>روی بازی در کتابخانه استیم خود راست-کلیک کرده و گزینه “Properties” را انتخاب کنید.</li>
<li>به بخش "Launch Options" بروید.</li>
<li>در تکست باکس عبارت<code>%gamemoderun %command</code> را وارد کنید.</li>
</ol>
<blockquote>
<p>با این راهنما، شما میتوانید از ابزارهای قدرتمند گیمینگ در پارچ لینوکس برای نصب و اجرای بازی‌ها به‌صورت یکپارچه استفاده کنید. در صورت نیاز به اطلاعات بیشتر، به مستندات رسمی هر ابزار مراجعه کنید.</p>
</blockquote>

94
fa/IDEs.md Normal file
View file

@ -0,0 +1,94 @@
---
title: IDEها در پارچ
description: معرفی و آموزش نصب IDEهای محبوب در پارچ لینوکس
published: true
date: 2025-02-13T07:53:24.094Z
tags: ide, ides, vscode, code, editor, development, programing, برنامه‌نویسی, ادیتور, کد
editor: markdown
dateCreated: 2025-02-07T18:55:15.321Z
---
# ابزارهای توسعه نرم‌افزار (IDE)
## درباره
ابزارهای توسعه نرم‌افزار (Integrated Development Environment - IDE) محیط‌هایی هستند که شامل ویرایشگر متن، مدیریت پروژه، دیباگر(Debuger) و ابزارهای دیگر برای توسعه نرم‌افزار می‌باشند.
## IDEهای محبوب
### 1. **Visual Studio Code**
Visual Studio Code (VS Code) یکی از محبوب‌ترین و پرکاربرترین ویرایشگرهای کد است که توسط Microsoft توسعه داده شده.
#### نسخه‌های موجود:
- **Code - OSS**: بسته منبع‌باز رسمی آرچ لینوکس. این نسخه یک پیکربندی برای فعال‌سازی [Open VSX](https://open-vsx.org/) دارد.
نصب:
```bash
sudo pacman -S code
```
- **Visual Studio Code**: نسخه اختصاصی و مالکیتی مایکروسافت.
نصب:
```bash
paru -S visual-studio-code-bin
```
- **VSCodium**: نسخه آزاد جامعه که داده‌های مربوط به رفتار نرم‌افزار را به سرویس‌دهندگان ارسال نمی‌کند و پیکربندی [Open VSX](https://open-vsx.org/) را فراهم می‌کند.
**نصب:**
```bash
paru -S vscodium
```
### 2. **JetBrains IntelliJ IDEA**
IntelliJ IDEA یک IDE حرفه‌ای برای توسعه نرم‌افزارهای Java است. این ابزار دارای ویژگی‌های قدرتمندی برای توسعه کد، مدیریت پروژه و تست است.
**نصب:**
```bash
sudo pacman -S intellij-idea-community-edition
```
### 3. **Eclipse**
Eclipse یک IDE آزاد برای توسعه نرم‌افزارهای Java است که از زبان های متنوعی پشتیبانی میکند.
**نصب:**
```bash
sudo pacman -S eclipse-java-bin
```
### 4. **PyCharm**
PyCharm یک IDE اختصاصی برای زبان برنامه‌نویسی Python است که توسط JetBrains توسعه یافته است.
**نصب:**
```bash
sudo pacman -S pycharm-community-edition
```
### 5. Zed
Zed یک ویرایشگر کد جدید است که با زبان برنامه‌نویسی Rust ساخته شده و بر سرعت، همکاری و هوش مصنوعی (AI) تمرکز دارد و از زبان های مختلف پشتیبانی میکند.
**نصب:**
```bash
sudo pacman -S zed
```
### 6. Atom/Pulsar
Pulsar یک ویرایشگر متن منبع‌باز است Pulsar یک ویرایشگر متن آزاد است که پس از توقف رسمی توسعه Atom توسط GitHub، توسط جامعه توسعه دهندگان توسعه یافته و به طور خاص برای تجربه‌ای سبک و قابل شخصی‌سازی طراحی شده است.
**نصب:**
```bash
paru -S pulsar
```
### 7. NetBeans
NetBeans یک IDE آزاد و قدرتمند است که توسط Oracle توسعه داده شده و به طور اصلی برای توسعه نرم‌افزارهای Java طراحی شده است. این ابزار از زبان‌های برنامه‌نویسی دیگر نیز پشتیبانی می‌کند
**نصب:**
```bash
sudo pacman -S netbeans
```
### 8. **All JetBrains products**
جعبه ابزار جتبرینز یک نرم‌افزار مدیریتی است که به شما امکان می‌دهد تا IDEهای مختلف جتبرینز مانند IntelliJ IDEA، PyCharm، WebStorm و... را به راحتی نصب و مدیریت کنید. این ابزار از ویژگی‌هایی مانند بروزرسانی خودکار و جابه‌جایی بین نسخه‌های مختلف پشتیبانی می‌کند.
**نصب:**
```bash
sudo pacman -S jetbrains-toolbox
```
### 8. Vim/NeoVim
NeoVim به تنهایی یک IDE کامل نیست، اما با به‌کارگیری افزونه‌های فراوانی که برای آن توسعه یافته می‌توان آن را به یک محیط توسعه مشابه IDE تبدیل کرد.
> برای جزئیات بیشتر درباره NeoVim و چگونگی تبدیل آن به یک IDE کامل، می‌توانید به [صفحه مربوط به Neovim در ویکی پارچ](https://wiki.parchlinux.com/fa/neovim) مراجعه کنید.
{.is-info}

87
fa/Package-management.md Normal file
View file

@ -0,0 +1,87 @@
---
title: مدیریت بسته
description:
published: true
date: 2024-05-07T16:45:52.400Z
tags:
editor: markdown
dateCreated: 2024-05-07T16:45:46.483Z
---
# مدیریت بسته در پارچ لینوکس
## مدیر بسته
مدیر بسته در پارچ لینوکس با نام pacman شناخته می‌شود.
طبق ویکی ArchLinux:
> مدیر بسته pacman یکی از ویژگی‌های ممتاز ارچ لینوکس است. این مدیر بسته فرمت ساده‌ای از بسته‌های دودویی را با یک سیستم ساخت آسان ترکیب می‌کند. هدف از pacman، مدیریت آسان بسته‌هااست ،بگونه‌ای که بتوان به راحتی بسته‌ها را مدیریت کرد، و از مخازن رسمی یا غیر رسمی هستند.
> pacman با هماهنگ کردن فهرست بسته‌ها با سرور اصلی، سیستم را به‌روز نگه می‌دارد. این مدل سرور/کاربر همچنین به کاربر اجازه می‌دهد که بسته‌ها را با یک دستور ساده دانلود/نصب کند، همراه با تمامی وابستگی‌های مورد نیاز.
> pacman به زبان برنامه‌نویسی C نوشته شده است و از فرمت tar bsdtar(1) برای بسته‌بندی استفاده می‌کند.
## چگونگی کار pacman
اینجا یک کتابچه راهنمای کوچک است که به شما در استفاده از pacman کمک می‌کند:
### عملیات اساسی
| عمل | Arch | Red Hat/Fedora | Debian/Ubuntu | SLES/openSUSE | Gentoo |
|--------|------|-----------------|----------------|-----------------|--------|
| جستجو برای بسته(ها) | `pacman -Ss` | `dnf search` | `apt search` | `zypper search` یا `zypper se [-s]` | `emerge --search` (`-s`) یا `emerge --searchdesc` (`-S`) |
| نصب بسته(ها) با نام | `pacman -S` | `dnf install` | `apt install` | `zypper install` یا `zypper in` | `emerge` |
| گرفتن بسته‌های منبع و وابستگی‌های ساخت | `makepkg -s PKGBUILD` | `dnf builddep` | `apt build-dep` | `zypper source-install` (`zypper si`) یا `zypper install -d` | `emerge`، یا به صراحت `emerge --with-bdeps` |
| چاپ اهداف بدون انجام عملیات | `pacman --print` (یا `-p`) | `dnf --setopt=tsflags=test` | `apt --simulate` (یا `-s`، `--dry-run`، `--just-print`) | `zypper --dry-run` | `emerge --pretend` (`-p`) |
| تغییر تأییدات | `pacman --confirm` یا `pacman --noconfirm` | `dnf --assumeyes` (`-y`) یا `dnf --assumeno` | `apt --yes` (`-y`) | `zypper --non-interactive` (`-n`) یا `zypper --no-confirm` (`-y`) | `emerge --ask` (`-a`) |
| بازآوری مخزن بسته محلی | `pacman -Sy` | `dnf check-update` یا `dnf makecache` یا `dnf upgrade` | `apt update` | `zypper refresh` یا `zypper ref` `[-s]` | `emerge --sync` |
| ارتقاء بسته‌ها | `pacman -Syu` | `dnf upgrade` | `apt upgrade` | `zypper update` یا `zypper up` | `emerge -[a]uDN @world` |
| ارتقاء بسته‌ها (ارتقاء‌های پیچیده) | `pacman -Syu` | `dnf distro-sync` | `apt dist-upgrade` | `zypper dup` | `emerge -[a]uDN @world` |
| حذف بسته(ها) و وابستگی‌ها | `pacman -Rs` | `dnf remove` | `apt autoremove` | `zypper remove` یا `zypper rm` | `emerge --depclean` (`-c`) |
| حذف بسته(ها) و فایل‌های پیکربندی | `pacman -Rn` | ? | `apt purge` | ? | n/a |
| حذف بسته(ها)، وابستگی‌ها و فایل‌های پیکربندی | `pacman -Rns` | ? | `apt autoremove --purge` | ? | n/a |
| حذف وابستگی‌های نیازمند | `pacman -Qdtq | pacman -Rs -` `` (`-Qdttq` for optional deps)| `dnf autoremove` | `apt autoremove` | `zypper rm -u` یا `zypper packages --unneeded` | `emerge --depclean` (`-c`) |
| حذف بسته‌هایی که در مخازن نیستند | ```pacman -Rs $(pacman -Qmq)``` | `dnf repoquery --extras` | `aptitude purge '~o'` || ? |
| نشان دادن بسته نصب شده به صورت صریح | `pacman -D --asexplicit` | `dnf mark install` | `apt-mark manual` | `zypper install --force` | `emerge --select` (`-w`) |
| نصب بسته(ها) به عنوان وابستگی | `pacman -S --asdeps` | `dnf install` سپس `dnf mark remove` | `apt-mark auto` | n/a ([راه حل](https://bugzilla.opensuse.org/show_bug.cgi?id=1175678)) | `emerge --oneshot` (`-1`) |
| فقط دانلود بسته(ها) | `pacman -Sw` | `dnf download` | `apt install --download-only` یا `apt download` | `zypper --download-only` | `emerge --fetchonly` (`-f`) |
| پاکسازی حافظه‌های محلی | `pacman -Sc` یا `pacman -Scc` | `dnf clean all` | `apt autoclean` یا `apt clean` | `zypper clean` | `eclean distfiles` |
| شروع یک پوسته | | `dnf shell` | | `zypper shell` ||
### استعلام بسته‌های خاص
| عمل | Arch | Red Hat/Fedora | Debian/Ubuntu | SLES/openSUSE | Gentoo |
|--------|------|-----------------|----------------|-----------------|--------|
| نمایش اطلاعات بسته | `pacman -Si` یا `pacman -Qi` | `dnf list` یا `dnf info` | `apt show` یا `apt-cache policy` | `zypper info` یا `zypper if` | `emerge -S`، `emerge -pv` یا `eix` |
| نمایش اطلاعات بسته محلی | `pacman -Qi` | `rpm -qi` / `dnf info installed` | `dpkg -s` یا `aptitude show` | `zypper --no-remote info` یا `rpm -qi` | `emerge -pv` یا `emerge -S` |
| نمایش اطلاعات بسته از راه دور | `pacman -Si` | `dnf info` | `apt-cache show` یا `aptitude show` | `zypper info` | `emerge -pv` و `emerge -S` یا `equery meta` |
| نمایش فایل‌های بسته محلی | `pacman -Ql` | `rpm -ql` | `dpkg -L` | `rpm -ql` | `equery files` یا `qlist` |
| نمایش فایل‌های بسته از راه دور | `pacman -Fl` | `dnf repoquery -l` یا `repoquery -l` | `apt-file list` || `pfl` |
| استعلام بسته‌ای که فایل را فراهم می‌کند | `pacman -Qo` | `rpm -qf` (نصب شده) یا `dnf provides` (همه) یا `repoquery -f` | `dpkg -S` یا `dlocate` | `rpm -qf` (نصب شده) یا `zypper search -f` (همه) | `equery belongs` یا `qfile` |
| لیست فایل‌ها در بسته | `pacman -Ql` یا `pacman -Fl` | `dnf repoquery -l` | `dpkg-query -L` | `rpm -ql` | `equery files` یا `qlist` |
| نمایش فراهم کننده‌های معکوس | `pacman -F` | `dnf provides` | `apt-file search` | `zypper what-provides` یا `zypper wp` (دقیق)
یا `zypper se --provides` (مبهم) | `equery belongs` (نصب شده) یا `pfl` |
| جستجو بسته با فایل | `pacman -F` | `dnf provides` | `apt-file search` یا `auto-apt` | `zypper search -f` | `equery belongs` یا `qfile` |
| نمایش تغییرات بسته | `pacman -Qc` | `dnf changelog` | `apt-get changelog` | `rpm -q --changelog` | `equery changes -f` |
### AUR
> مخزن کاربران Arch (AUR) یک مخزن برای کاربران Arch است که توسط جامعه پشتیبانی می‌شود. این مخزن شامل توضیحات بسته‌ها (PKGBUILDs) است که به شما اجازه می‌دهد یک بسته را از منبع با makepkg کامپایل کرده و سپس آن را از طریق pacman نصب کنید. AUR برای سازماندهی و به اشتراک گذاری بسته‌های جدید از جامعه ایجاد شده است و برای کمک به اضافه کردن بسته‌های محبوب به مخزن اضافی، بروز شدن پکیج‌های معروف را تسریع می‌کند.
تعداد زیادی از بسته‌های جدیدی که وارد مخازن رسمی می‌شوند ابتدا در AUR شروع می‌شوند. در AUR، کاربران قادر به ارسال ساخت‌های بسته خود (PKGBUILD و فایل‌های مرتبط) هستند. جامعه AUR قادر به رای‌گیری برای بسته‌ها در AUR است. اگر یک بسته به اندازه کافی محبوب شود - تهیه شده با مجوز سازگار و تکنیک بسته‌بندی خوب - ممکن است به مخزن اضافی وارد شود (که مستقیماً توسط pacman یا از طریق سیستم ساخت Arch قابل دسترس است).
### مدیر AUR
Parch Linux Paru را به عنوان مدیر AUR دارد.
استفاده از Paru مانند استفاده از pacman است، با همان نحوه‌ی نوشتاری می‌توانید به‌راحتی بسته‌ها را از AUR نصب کنید.
#### استفاده از Paru
در زیر چند دستور paru مفید آمده است:
| دستور | توضیحات |
| --- | --- |
| `paru` | بروزرسانی کامل سیستم |
| `paru -Syu` | بروزرسانی کامل سیستم |
| `paru -S نام‌برنامه` | نصب برنامه از AUR |
| `paru نام‌برنامه` | نصب برنامه از AUR، با انتخاب از لیست |
| `paru -Sc` | پاک کردن حافظه‌های پنهان Pacman و Paru |
| `paru -Ss نام‌برنامه` | جستجو برای یک بسته |

25
fa/Tips-and-tricks.md Normal file
View file

@ -0,0 +1,25 @@
---
title: نکات و ترفندها
description:
published: true
date: 2024-05-05T08:06:43.325Z
tags:
editor: markdown
dateCreated: 2024-05-05T08:06:21.916Z
---
# نکات و ترفند ها
## امضای GPG معتبر نیست
اگر در حال دانلود یک برنامه جدید یا ارتقاء یک سیستم هستید و با مشکلی مواجه شدید که نشان می دهد امضای GPG معتبر نیست، باید این موارد را انجام دهید:
### بسته archlinux-keyring را به روز کنید
اگر مشکل gpg از بسته‌های archlinux است، برای دریافت آخرین کلیدها باید این بسته را دوباره نصب کنید.
```bash
sudo pacman -Sy
sudo pacman -S archlinux-keyring
```
## اندازه فضای روت سیستم لایو کم است
اگر نیاز به استفاده از پارچ لینوکس لایو دارید و به فضای بیشتری برای روت لایو نیاز دارید، باید این دستور را اجرا کنید:
```bash
sudo mount -o remount,size=1G /run/archiso/cowspace
```
دستور بالا فایل سیستم روت را به 1G افزایش می دهد، اگر به فضای بیشتری نیاز دارید دستور 1G را به چیز دیگری تغییر دهید، به عنوان مثال: 4G

51
fa/Virtualization.md Normal file
View file

@ -0,0 +1,51 @@
---
title: مجازی سازی در پارچ لینوکس
description:
published: true
date: 2024-05-30T14:35:08.787Z
tags:
editor: markdown
dateCreated: 2024-05-30T14:06:15.896Z
---
## مجازی سازی چیست؟
گرفته شده از [ویکی پدیا](https://wiki.js.org):
>در کامپیوتر، مجازی سازی عمل ایجاد یک نسخه مجازی (و نه واقعی) چیزی در همان سطح انتزاعی، از جمله پلت فرم های سخت افزار کامپیوتر مجازی، دستگاه های ذخیره سازی و منابع شبکه کامپیوتری است.
ماشین مجازی یک کامپیوتر شبیه سازی شده است که در داخل یک کامپیوتر دیگر اجرا می شود. کامپیوتر شبیه سازی شده اغلب مهمان نامیده می شود، در حالی که ماشین واقعی میزبان نامیده می شود.
نمونه های محبوب نرم افزارهای کلاینت مجازی سازی شامل Oracle VirtualBox، GNOME Boxes، VMware Workstation (غیر آزاد) و QEMU است.
در حالی که شما در انتخاب نرم افزاری که می خواهید استفاده کنید آزاد هستید، ما به شما توصیه می کنیم از GNOME Boxes استفاده کنید.
## GNOME Boxes
>Boxes برنامه ای است که به شما امکان دسترسی به ماشین های مجازی را می دهد که به صورت محلی یا از راه دور اجرا می شوند. همچنین به شما امکان می دهد به صفحه نمایش یک کامپیوتر از راه دور متصل شوید.
### نصب Boxes
نصب Boxes در پارچ مثل آب خوردن است. تنها کاری که باید انجام دهید این است که `sudo pacman -S gnome-boxes` را در ترمینال خود اجرا کنید و سپس راه اندازی مجدد کنید. پس از راه اندازی رایانه، Boxes را خواهید دید.
## Oracle VirtualBox
> VirtualBox یک محصول مجازی سازی قدرتمند x86 و AMD64/Intel64 برای مصارف سازمانی و خانگی است. VirtualBox نه تنها یک محصول بسیار غنی و با کارایی بالا برای مشتریان سازمانی است، بلکه تنها راه حل حرفه ای است که تحت شرایط مجوز عمومی عمومی گنو (GPL) نسخه 3 به صورت رایگان به عنوان نرم افزار منبع باز در دسترس است.
### نصب VirtualBox
با اجرای `sudo pacman -S virtualbox` می توانید بسته اصلی VirtualBox را نصب کنید.
بعد، باید `sudo pacman -S virtualbox-host-dkms` را اجرا کنید.
برای کامپایل ماژول های VirtualBox ارائه شده توسط virtualbox-host-dkms، همچنین باید بسته های هدر مناسب را برای هسته نصب شده خود نصب کنید، به عنوان مثال:
- `sudo pacman -S linux-headers` برای هسته لینوکس
- `sudo pacman -S linux-lts-headers` برای هسته Linux-LTS
- `sudo pacman -S linux-zen-headers` برای هسته Linux-ZEN
- `sudo pacman -S linux-hardened-headers` برای هسته Linux-HARDENED
فراموش نکنید که بعد از نصب ریستارت کنید.
### فعال کردن ویژگی های اضافی VirtualBox
> بسته افزودنی Oracle VirtualBox ویژگی‌های اضافی را ارائه می‌کند و تحت یک مجوز غیر رایگان فقط برای استفاده شخصی منتشر می‌شود. برای نصب آن، بسته [virtualbox-ext-oracleAUR](https://aur.archlinux.org/packages/virtualbox-ext-oracle/) در دسترس است.
به دلایلی، ویژگی‌های اضافی در VirtualBox (مثلاً نصب یک دستگاه رسانه خارجی مانند یک USB به مهمان) در بسته اصلی گنجانده نشده است و برای استفاده از این ویژگی‌ها باید بسته افزونه را نصب کنید.
شما می توانید این بسته را نصب کنید و از این ویژگی ها استفاده کنید:
1. اجرای `paru -S virtualbox-ext-oracle --noconfirm` در ترمینال. (پارچ لینوکس به طور پیش فرض گنجانده شده است، اما ممکن است بخواهید به جای آن از `yay` or `aura` استفاده کنید.)
2. اجرای `sudo usermod -aG vboxusers YOUR-USERNAME` در ترمینال. (نام کاربری خود را به جای `YOUR-USERNAME` در دستور قرار دهید.)
در پایان، راه اندازی مجدد را فراموش نکنید، زیرا لازم است.

135
fa/anti403.md Normal file
View file

@ -0,0 +1,135 @@
---
title: رفع تحریم‌ها با ابزار های مختلف
description: مخصوص کاربران ایرانی پارچ
published: true
date: 2024-07-28T14:18:02.896Z
tags: تحریم, پارچ, رفع‌تحریم
editor: markdown
dateCreated: 2024-07-28T14:17:52.101Z
---
# رفع تحریم
شاید برای شماهم پیش اومده باشه که موقع استفاده از یک ابزار خاص به شما خطای ۴۰۳ برگردونه. این خطا به معنی دسترسی غیرمجاز یا به عبارتی محدود شدن دسترسی شما با آی‌پی ایران به این ابزارها است.
## چگونگی رفع تحریم
### با استفاده از ساناد (DNS)
برای رفع تحریم با استفاده از ساناد (سامانه نام دامنه) یا همان (DNS) شما می‌تونید از روش‌های زیر استفاده کنید:
#### تنظیم با استفاده از برنامه DNSCH
برای تنظیم ساناد با استفاده از برنامه‌های گفته شده، در ابتدا نیاز است که این برنامه‌ها را نصب کنید.
هردو برنامه در مخازن پارچ موجود هستند.
برای نصب dnsch:
```bash
sudo pacman -S dnsch
```
##### **نحوه استفاده از dnsch:**
تنظیم ساناد‌های مختلف
```
sudo dnsch {g|sh|ag|cf|403|bg|rd|el}
```
تنظیم ساناد سفارشی
```
sudo dnsch --set 1.2.3.4 1.2.3.4
```
حذف سانادها
```
sudo dnsch {-c|--clear}
```
دریافت پینگ از سانادهای مختلف
```
sudo dnsch {-p|--ping}
```
برگرداندن به پیشفرض سیستمی
```
sudo dnsch {-r|--restore}
```
#### با استفاده از نام‌بان:
برای نصب نام‌بان بر روی توزیع پارچ کافی هستش تا دستور زیر رو داخل پایانه (ترمینال) وارد کنید:
```bash
sudo pacman -S namban
```
##### استفاده از نام‌بان
نام بان یک محیط گرافیکی رو داره که استفاده ازش رو بسیار ساده‌تر می‌کنه. فقط کافی هستش تا برنامه‌رو اجرا کنید تا با محیط زیر روبرو بشید:
![نام‌بان.png](/نام‌بان.png)
### با استفاده از پروکسی
برای رفع تحریم با استفاده از پروکسی می‌توانید از برنامه‌هایی مثل وارپ پلاس، آبلیوین، نکوری، کاربراتور و هیدیفای استفاده کنید.
#### وارپ پلاس و آبلیوین
وارپ پلاس و آبلیوین دسترسی شمارو به شبکه وارپ کلودفلیر ساده تر می‌کند، در آبلیوین که دارای یک محیط گرافیکی هستش شما میتونید در محیط های گنوم و پلاسما به سادگی از این برنامه استفاده کنید، اگر نیازی به محیط گرافیکی ندارید میتونید از دستور وارپ پلاس به این منظور استفاده کنید.
##### نصب در پارچ
شما این دو برنامه رو باید از aur نصب کنید، برای نصب:
```bash
paru -S oblivion-desktop-bin warp-plus-bin --noconfirm
```
را در محیط پایانه خودتون اجرا کنید (بدون نیاز به sudo)
##### استفاده از آبلیوین و وارپ پلاس:
برای اجرای وارپ پلاس شما نیازمند باز کردن ترمینال‌(پایانه) خودتون هستید.
پرچم‌های دستور وارپ پلاس:
```
NAME
warp-plus
FLAGS
-4 only use IPv4 for random warp endpoint
-6 only use IPv6 for random warp endpoint
-v, --verbose enable verbose logging
-b, --bind STRING socks bind address (default: 127.0.0.1:8086)
-e, --endpoint STRING warp endpoint
-k, --key STRING warp key
--dns STRING DNS address (default: 1.1.1.1)
--gool enable gool mode (warp in warp)
--cfon enable psiphon mode (must provide country as well)
--country STRING psiphon country code (valid values: [AT BE BG BR CA CH CZ DE DK EE ES FI FR GB HR HU IE IN IT JP LV NL NO PL PT RO RS SE SG SK UA US]) (default: AT)
--scan enable warp scanning
--rtt DURATION scanner rtt limit (default: 1s)
--cache-dir STRING directory to store generated profiles
--tun-experimental enable tun interface (experimental)
--fwmark UINT set linux firewall mark for tun mode (default: 4981)
--reserved STRING override wireguard reserved value (format: '1,2,3')
--wgconf STRING path to a normal wireguard config
-c, --config STRING path to config file
--version displays version number
```
بعد از اتصال میتونید از پروکسی های http و یا socks5 با این آیپی و پورت استفاده کنید:
```
127.0.0.1:8086
```
##### استفاده از آبلیوین:
کافی هستش تا برنامه رو اجرا کنید و سپس در محیط باز شده بر روی دکمه موجود بزنید بعد از مدتی برنامه به شبکه وارپ متصل می‌شود.
![آبلیوین.png](/آبلیوین.png)
##### استفاده از کاربراتور
کاربراتور یکی دیگر از برنامه‌های خوب برای اتصال به شبکه تور می‌باشد که به صورت پیشفرض در مخازن پارچ موجود است.
برای نصب:
```bash
sudo pacman -S carburetor
```
برای اجرا کافی هستش تا اون رو از منوی برنامه‌ها اجرا کنید تا با صحنه زیر روبرو بشید:
![کاربراتور.png](/کاربراتور.png)
بعد از اجرا شدن بر روی connect بزنید تا به شبکه تور وصل بشید، بعد از اتصال پورت های مربوط به پروکسی socks و http به شما نشان داده می‌شود، همچنین می‌توانید از منوی همبرگری پل های تور را برای اتصال بهتر ویرایش کنید.

322
fa/bash.md Normal file
View file

@ -0,0 +1,322 @@
---
title: پوسته Bash
description:
published: true
date: 2025-01-05T16:27:50.157Z
tags: bash
editor: markdown
dateCreated: 2025-01-05T13:37:50.828Z
---
# پوسته Bash
Bash (پوستهٔ بورن-دوباره) یک پوستهٔ خط فرمان/زبان برنامه‌نویسی است که توسط پروژهٔ گنو توسعه یافته است. نام آن به پیشینی خود، پوستهٔ بورن که مدت‌هاست منسوخ شده، اشاره دارد. Bash می‌تواند بر روی اکثر سیستم‌عامل‌های شبیه یونیکس، از جمله گنو/لینوکس، اجرا شود.
>در توزیع پارچ، پوستهٔ bash به عنوان پوستهٔ پیشفرض استفاده می‌شود.
{.is-info}
## فراخوانی
رفتار Bash می‌تواند بسته به نحوهٔ فراخوانی آن تغییر کند. در زیر توضیحاتی دربارهٔ حالت‌های مختلف آمده است.
اگر Bash از طریق ورود به یک TTY، توسط یک دیمون SSH یا روش‌های مشابه راه‌اندازی شود، به آن پوستهٔ ورود (login shell) گفته می‌شود. این حالت همچنین می‌تواند با استفاده از گزینهٔ خط فرمان -l یا --login فعال شود.
Bash زمانی که ورودی، خروجی و خطای استاندارد آن به یک ترمینال متصل باشد (برای مثال، زمانی که در یک شبیه‌ساز ترمینال اجرا می‌شود) و با گزینهٔ -c یا آرگومان‌های غیرگزینه‌ای (برای مثال، bash script) شروع نشود، به عنوان یک پوستهٔ تعاملی (interactive shell) در نظر گرفته می‌شود. تمام پوسته‌های تعاملی فایل‌های /etc/bash ، .bashrc و ~/.bashrc را بارگذاری می‌کنند، در حالی که پوسته‌های تعاملی ورود همچنین فایل‌های /etc/profile و ~/.bash_profile را نیز بارگذاری می‌کنند.
>**توجه:** در پارچ، /bin/sh (که قبلاً به عنوان اجرایی شل بورن استفاده می‌شد) به bash لینک نمادین شده است. اگر Bash با نام sh فراخوانی شود، سعی می‌کند رفتار راه‌اندازی نسخه‌های تاریخی sh را تقلید کند، از جمله سازگاری با POSIX.
{.is-info}
### پروندهٔ‌های پیکربندی
Bash سعی خواهد کرد مجموعه‌ای از فایل‌های راه‌اندازی را بسته به نحوهٔ فراخوانی آن اجرا کند.
| پرونده | توضیحات | پوسته‌های ورود (به یاد داشته باشید) | پوسته‌های تعاملی غیر ورود |
|-----------------------|-------------------------------------------------------------------------|-------------------------------------|---------------------------|
| /etc/profile | تنظیمات برنامه‌ها را در /etc/profile.d/*.sh و /etc/bash.bashrc بارگذاری می‌کند. | بله | خیر |
| ~/.bash_profile | برای هر کاربر، پس از /etc/profile. اگر این فایل وجود نداشته باشد، به ترتیب ~/.bash_login و ~/.profile بررسی می‌شوند. فایل الگو /etc/skel/.bash_profile همچنین ~/.bashrc را بارگذاری می‌کند. | بله | خیر |
| ~/.bash_logout | برای هر کاربر، پس از خروج از یک پوستهٔ ورود. | بله | خیر |
| /etc/bash.bash_logout | بستگی به پرچم کامپایل -DSYS_BASH_LOGOUT="/etc/bash.bash_logout" دارد. پس از خروج از یک پوستهٔ ورود. | بله | خیر |
| /etc/bash.bashrc | بستگی به پرچم کامپایل -DSYS_BASHRC="/etc/bash.bashrc" دارد. /usr/share/bash-completion/bash_completion را بارگذاری می‌کند. | خیر | بله |
| ~/.bashrc | برای هر کاربر، پس از /etc/bash یا .bashrc. | خیر | بله |
>**توجه**:
پوسته‌های ورود می‌توانند زمانی که با آرگومان --login فراخوانی شوند، غیرتعامل‌پذیر (non-interactive) باشند. در حالی که پوسته‌های تعاملی غیر ورود، فایل ~/.bash_profile را بارگذاری نمی‌کنند، اما همچنان محیط را از فرآیند والد خود (که ممکن است یک پوستهٔ ورود باشد) به ارث می‌برند.
{.is-info}
### پوسته و متغیرهای محیطی
رفتار Bash و برنامه‌هایی که توسط آن اجرا می‌شوند، می‌تواند تحت تأثیر تعدادی از متغیرهای محیطی قرار گیرد. متغیرهای محیطی برای ذخیرهٔ مقادیر مفید مانند دایرکتوری‌های جستجوی فرمان یا مرورگری که باید استفاده شود، به کار می‌روند. زمانی که یک پوسته یا اسکریپت جدید راه‌اندازی می‌شود، متغیرهای والد خود را به ارث می‌برد و بنابراین با یک مجموعه داخلی از متغیرهای پوسته شروع می‌کند.
این متغیرهای پوسته در Bash می‌توانند صادر شوند تا به متغیرهای محیطی تبدیل شوند:
```bash
VARIABLE=content
export VARIABLE
```
یا با یک میانبر:
```bash
export VARIABLE=content
```
متغیرهای محیطی به طور معمول در `~/.profile` یا `/etc/profile` قرار می‌گیرند تا سایر پوسته‌های سازگار با بورن نیز بتوانند از آن‌ها استفاده کنند.
----
## خط فرمان
خط فرمان Bash توسط کتابخانه‌ای جداگانه به نام Readline مدیریت می‌شود. Readline سبک‌های میانبر emacs و vi را برای تعامل با خط فرمان فراهم می‌کند، به عبارت دیگر، امکان حرکت به جلو و عقب بر اساس کلمات، حذف کلمات و غیره را فراهم می‌آورد. همچنین، مدیریت تاریخچهٔ دستورات ورودی نیز بر عهدهٔ Readline است. در نهایت، این کتابخانه به شما اجازه می‌دهد تا ماکروها را ایجاد کنید.
### تکمیل‌خودکار با کلید tab
تکمیل خودکار با کلید <kbd>Tab</kbd> گزینه‌ای است برای تکمیل خودکار دستورات تایپ شده با فشار دادن کلید <kbd>Tab</kbd> (که به طور پیش‌فرض فعال است).
#### برنامه‌ها و گزینه‌های رایج
به طور پیش‌فرض، Bash فقط دستورات، نام فایل‌ها و متغیرها را با استفاده از کلید <kbd>Tab</kbd> تکمیل می‌کند. بستهٔ `bash-completion` این قابلیت را گسترش می‌دهد و تکمیل‌های خودکار تخصصی‌تری را برای دستورات رایج و گزینه‌های آن‌ها اضافه می‌کند، که می‌توان با بارگذاری فایل `/usr/share/bash-completion/bash_completion`(که قبلاً در /etc/bash یا .bashrc پارچ بارگذاری شده است) آن را فعال کرد. با استفاده از bash-completion، تکمیل‌های معمولی (مانند ls file.* Tab Tab) رفتار متفاوتی خواهند داشت؛ با این حال، می‌توان آن‌ها را با استفاده از دستور `compopt -o bashdefault program` دوباره فعال کرد .
#### سفارشی‌سازی برای هر دستور
> توجه: استفاده از دستور `complete` ممکن است با bash-completion تداخل ایجاد کند.
{.is-info}
به طور پیش‌فرض، Bash فقط نام فایل‌ها را پس از یک دستور با استفاده از کلید Tab تکمیل می‌کند.
می‌توانید آن را تغییر دهید تا نام دستورات را نیز با استفاده از `complete -c` تکمیل کند:
```bash
~/.bashrc
-----
complete -c man which
```
یا می‌توانید نام دستورات و نام فایل‌ها را با استفاده از گزینه `-cf` تکمیل کنید:
```bash
complete -cf sudo
```
برای گزینه‌های بیشتر در مورد تکمیل، به بخش "§Programmable Completion" در مستندات bash(1) مراجعه کنید.
### تاریخچه
#### تکمیل از تاریخچه
شما می‌تونید با بایند کردن کلید‌های جهت بالا و پایین در تاریخچه پوستهٔ بش جابه‌جا بشید:
```bash
bind '"\e[A": history-search-backward'
bind '"\e[B": history-search-forward'
```
برای تحت تأثیر قراردادن همه برنامه‌های readline:
در فایل .inputrc:
```bash
"\e[A": history-search-backward
"\e[B": history-search-forward
```
#### شخصی‌سازی تاریخچه
مقدار `HISTCONTROL` می‌تواند باعث شود تا یک سری دستور خاص در تاریخچه ثبت نشوند. برای مثال
برای متوقف کردن ثبت دستورهای متوالی مشابه:
```bash
~/.bashrc
------
export HISTCONTROL=ignoredups
```
برای حذف تمام دستورات مشابه به جز آخرین دستور:
```bash
~/.bashrc
------
export HISTCONTROL=erasedups
```
برای جلوگیری از ذخیرهٔ دستورات که با یک فاصله شروع می‌شوند:
```bash
~/.bashrc
------
export HISTCONTROL=ignorespace
```
برای جلوگیری از ذخیرهٔ دستورات مشابه متوالی و دستورات که با یک فاصله شروع می‌شوند:
```bash
~/.bashrc
------
export HISTCONTROL=ignoreboth
```
برای حذف تمام دستورات مشابه به جز آخرین دستور و دستورات که با یک فاصله شروع می‌شوند:
```bash
~/.bashrc
------
export HISTCONTROL="erasedups:ignorespace"
```
به bash(1) § HISTCONTROL برای جزئیات بیشتر مراجعه کنید.
#### غیرفعال کردن تاریخچه
برای غیرفعال کردن تاریخچه به صورت موقت از دستور زیر استفاده کنید:
```bash
set +o history
```
این دستور به صورت موقت نوشتن تاریخچه را در پروندهٔ `$HISTFILE` متوقف می‌کند.
به عنوان مثال، اکنون می‌توانید پسوردها را با استفاده از دستور `printf secret | sha256sum` هش کنید، یا استفاده از GPG را با دستور `gpg -eaF secret-pubkey.asc` پنهان کنید و در این صورت رمز شما بر روی دیسک نوشته نخواهد شد.
برای فعال‌سازی تاریخچه:
```bash
$ set -o history
```
برای غیرفعال کردن تمام تاریخچهٔ Bash:
در پروندهٔ `~/.bashrc` یا `/etc/profile`:
```bash
export HISTSIZE=0
```
... و فقط برای اطمینان، پروندهٔ تاریخچهٔ قدیمی خود را برای همیشه نابود کنید:
```bash
wipe -i -l2 -x4 -p4 "$HISTFILE"
ln -sv /dev/null "$HISTFILE"
```
### شبیه‌سازی قابلیت run-help Zsh
Zsh می‌تواند با فشار دادن Alt+h، راهنمای مربوط به دستوری که قبل از نشانگر (کرسر) قرار دارد را فراخوانی کند. رفتار مشابهی در Bash با استفاده از این دستور Readline به دست می‌آید:
در پروندهٔ `~/.bashrc`:
```bash
run-help() { help "$READLINE_LINE" 2>/dev/null || man "$READLINE_LINE"; }
bind -m vi-insert -x '"\eh": run-help'
bind -m emacs -x '"\eh": run-help'
```
فرض می‌شود که شما قادر به استفاده از حالت ویرایش Emacs (که به طور پیش‌فرض است) هستید.
### به اشتراک‌گذاری تاریخچه Bash در بین ماشین‌ها
Atuin تاریخچهٔ شل موجود شما را با یک پایگاه داده SQLite جایگزین می‌کند و زمینه‌های اضافی برای دستورات شما را ثبت می‌کند. علاوه بر این، امکان همگام‌سازی اختیاری و کاملاً رمزگذاری شدهٔ تاریخچهٔ شما بین ماشین‌ها را از طریق یک سرور Atuin فراهم می‌کند.
قبل از همگام‌سازی، زمان‌بندی تاریخچهٔ Bash را فعال کنید (با استفاده از دستور `export HISTTIMEFORMAT="%F %T "`). Atuin به خوبی با ابزارهایی مانند blesh-gitAUR و cmd-wrapped کار می‌کند تا تجربهٔ پایانه بهتری را در بین ماشین‌ها فراهم کند.
## نام مستعار (Aliases)
`alias` یک دستور است که امکان جایگزینی یک کلمه با یک رشتهٔ دیگر را فراهم می‌کند. این دستور معمولاً برای کوتاه کردن یک دستور سیستم یا افزودن آرگومان‌های پیش‌فرض به یک دستور که به طور منظم استفاده می‌شود، به کار می‌رود.
نام‌های مستعار شخصی می‌توانند در فایل `~/.bashrc` یا هر فایل جداگانه‌ای که از `~/.bashrc` بارگذاری می‌شود، ذخیره شوند. نام‌های مستعار سراسری (که بر تمام کاربران تأثیر می‌گذارند) باید در فایل `/etc/bash.bashrc` قرار گیرند.
## نکات و ترفندها
### هایلایت سینتکس و پیشنهادات خودکار
`ble.sh` (ویرایشگر خط Bash)، که به عنوان ^AUR^`blesh-git` بسته‌بندی شده است، یک ویرایشگر خط فرمان نوشته شده به زبان Bash خالص است که جایگزینی برای GNU Readline به شمار می‌رود. این ابزار دارای ویژگی‌های پیشرفته‌ای مانند هایلایت سینتکس، پیشنهادات خودکار، تکمیل منویی، اختصارات، حالت ویرایش Vim و توابع hook است. سایر ویژگی‌های جالب شامل خط وضعیت، اشتراک تاریخچه، پرامپت راست، پرامپت موقتی و عنوان xterm می‌باشد.
پس از نصب آن، در یک جلسه تعاملی بارگذاری کنید:
```bash
~/.bashrc
source /usr/share/blesh/ble.sh
```
تنظیمات به طور عمیق در فایل `~/.blerc` و در ویکی توضیح داده شده است. بستهٔ پایدار ^AUR^`blesh` نیز در دسترس است.
### دستور پیدا نشد
`pkgfile` شامل یک hook "دستور پیدا نشد" است که به طور خودکار در هنگام وارد کردن یک دستور ناشناخته، به جستجوی مخازن رسمی می‌پردازد.
برای فعال‌سازی این hook، باید آن را بارگذاری کنید، به عنوان مثال:
```bash
~/.bashrc
source /usr/share/doc/pkgfile/command-not-found.bash
```
سپس تلاش برای اجرای یک دستور غیرقابل دسترسی، اطلاعات زیر را نمایش می‌دهد:
```bash
$ abiword
abiword may be found in the following packages:
extra/abiword 3.0.1-2 /usr/bin/abiword
```
> **توجه**: ممکن است نیاز باشد که پایگاه داده pkgfile قبل از کارکرد این ویژگی به‌روزرسانی شود. {.is-warning}
غیرفعال کردن Ctrl+z در ترمینال
شما می‌توانید ویژگی <kbd>Ctrl+z</kbd> (که برنامه شما را متوقف یا می‌بندد) را با استفاده از کد زیر غیرفعال کنید:
```bash
#!/bin/bash
trap "" 20
adom
```
اکنون، وقتی به طور تصادفی <kbd>Ctrl+z</kbd> را در `adom`^AUR^ فشار می‌دهید به جای <kbd>Shift+z</kbd>، هیچ اتفاقی نخواهد افتاد زیرا <kbd>Ctrl+z</kbd> نادیده گرفته می‌شود.
### پاک کردن صفحه پس از خروج
برای پاک کردن صفحه پس از خروج از یک ترمینال مجازی:
```bash
~/.bash_logout
clear
reset
```
### "cd" خودکار هنگام وارد کردن فقط یک مسیر
Bash می‌تواند به طور خودکار `cd` را هنگام وارد کردن فقط یک مسیر در شل اضافه کند. به عنوان مثال:
```bash
$ /etc
bash: /etc: Is a directory
```
اما پس از افزودن یک خط به فایل `.bashrc`:
```bash
~/.bashrc
...
shopt -s autocd
...
```
شما به این صورت خواهید داشت:
```bash
[user@host ~]$ /etc
cd /etc
[user@host etc]$
```
### Autojump
`autojump-git`^AUR^ یک اسکریپت پایتون است که به شما اجازه می‌دهد با جستجوی رشته‌ها در یک پایگاه داده از مسیرهای پر بازدید کاربر، در سیستم فایل ناوبری کنید.
`zoxide` یک جایگزین است که ویژگی‌ها و بهبودهای عملکردی بیشتری نسبت به `autojump` اصلی دارد و می‌تواند به عنوان یک جایگزین مستقیم برای `autojump` عمل کند.
### جلوگیری از بازنویسی فایل‌ها
برای جلسهٔ جاری، برای جلوگیری از بازنویسی فایل‌های عادی موجود توسط هدایت خروجی شل:
```bash
$ set -o noclobber
```
این معادل `set -C` است.
برای پایدار کردن تغییرات برای کاربر خود:
```bash
~/.bashrc
...
set -o noclobber
```
برای بازنویسی دستی یک فایل در حالی که `noclobber` فعال است:
```bash
$ echo "output" >| file.txt
```
### استفاده از پشته دایرکتوری برای ناوبری
دستورات `pushd` و `popd` می‌توانند برای اضافه کردن یا حذف دایرکتوری‌ها به یک پشته در حین جابجایی به آن‌ها استفاده شوند. این می‌تواند برای "پخش مجدد" تاریخچهٔ ناوبری شما مفید باشد.
```bash
[user@host ~] pushd /tmp/dir1
[user@host /tmp/dir1] pushd /var/lib
[user@host /var/lib] popd
[user@host /tmp/dir1] popd
[user@host ~]
```
برای اطلاعات بیشتر به bash(1) § DIRSTACK مراجعه کنید.

View file

@ -0,0 +1,218 @@
---
title: کدام نسخه از پارچ لینوکس برای من مناسب است؟
description: این ویکی رسمی برای پارچ لینوکس است.
published: true
date: 2024-05-07T15:38:09.769Z
tags:
editor: markdown
dateCreated: 2024-05-07T15:31:48.197Z
---
## پارچ لینوکس نسخه پلاسما
### پلاسما دسکتاپ چیست؟
یک محیط دسکتاپ پر امکانات و بسیار قابل تنظیم که یک تجربه کاربری مدرن و بصری را ارائه می دهد. این محیط به خاطر انعطاف پذیری، گزینه های گسترده شخصی سازی و طیف وسیعی از برنامه ها و ابزار شناخته شده است.
<img src="https://github.com/parchlinux/parch-iso-plasma/raw/main/image/screenshot.png" alt="اسکرین شات از محیط دسکتاپ KDE Plasma">
### نرم افزارهای پیش نصب شده در پلاسما
<!DOCTYPE html>
<html lang="fa">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<style>
table {
border-collapse: collapse;
width: 100%;
}
th, td {
padding: 8px;
text-align: left;
border: 1px solid #ddd;
}
th {
background-color: #f0f0f0;
}
</style>
</head>
<body>
<table>
<tr>
<th>نام برنامه</th>
<th>توضیح</th>
<th>دسته</th>
</tr>
<tr>
<td>Tokodon</td>
<td>کلاینتی برای مرور فدی‌ورس</td>
<td>شبکه‌های اجتماعی</td>
</tr>
<tr>
<td>SocialNeochat</td>
<td>کلاینتی برای مرور ماتریکس</td>
<td>شبکه‌های اجتماعی</td>
</tr>
<tr>
<td>SocialPlasmaTube</td>
<td>کلاینتی برای تماشای پیرتوب و ویدیوهای یوتیوب </td>
<td>سرگرمی (ویدیو)</td>
</tr>
<tr>
<td>VLC Media Player</td>
<td>پخش‌کننده ویدئو نوشته شده با QT</td>
<td>سرگرمی (ویدیو)</td>
</tr>
<tr>
<td>Elisa</td>
<td>پخش‌کننده موسیقی ساده و آسان برای استفاده، نوشته شده با C++ و Kirigami</td>
<td>سرگرمی (موسیقی)</td>
</tr>
<tr>
<td>Firefox</td>
<td>مرورگر وب سریع، خصوصی و امن</td>
<td>وب‌گردی</td>
</tr>
<tr>
<td>MarkNote</td>
<td>یادداشت برداری با مارکداون</td>
<td>بهره‌وری</td>
</tr>
</table>
</body>
</html>
## پارچ لینوکس نسخه گنوم
### گنوم دسکتاپ چیست؟
یک محیط دسکتاپ کاربرپسند و مدرن است که تجربه‌ای روان و بصری برای کاربر فراهم می‌کند. این محیط با در نظر گرفتن سادگی، دسترسی‌پذیری و قابلیت شخصی‌سازی طراحی شده است. گنوم طیف وسیعی از ویژگی‌ها و برنامه‌ها را ارائه می‌دهد، از جمله یک مدیر فایل، یک مرورگر وب، یک ویرایشگر متن و مجموعه‌ای از ابزارهای کاربردی.
<img src="https://github.com/parchlinux/Parch-iso-gnome/raw/main/image/screenshot.png" alt="اسکرین شات از محیط دسکتاپ KDE Plasma">
### نرم افزارهای پیش نصب شده در گنوم
<!DOCTYPE html>
<html lang="fa">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<style>
table {
border-collapse: collapse;
width: 100%;
}
th, td {
padding: 8px;
text-align: left;
border: 1px solid #ddd;
}
th {
background-color: #f0f0f0;
}
</style>
</head>
<body>
<table>
<thead>
<tr>
<th>نام</th>
<th>کاربرد</th>
<th>دسته بندی</th>
</tr>
</thead>
<tbody>
<tr>
<td>Tuba</td>
<td>مروگر فدینورس</td>
<td>شبکه‌های اجتماعی</td>
</tr>
<tr>
<td>Fractal</td>
<td>مروگر ماتریکس</td>
<td>شبکه‌های اجتماعی</td>
</tr>
<tr>
<td>PipeLine</td>
<td>تماشای پیرتوب و یوتیوب</td>
<td>سرگرمی (ویدیو)</td>
</tr>
<tr>
<td>Celluloid</td>
<td>رابط کاربری MPV با GTK</td>
<td>سرگرمی (فیلم و موسیقی)</td>
</tr>
<tr>
<td>G4Music</td>
<td>پخش کننده موسیقی ساده و آسان</td>
<td>سرگرمی (موسیقی)</td>
</tr>
<tr>
<td>Firefox</td>
<td>مرورگر وب سریع، خصوصی و امن</td>
<td>وب‌گردی</td>
</tr>
<tr>
<td>Folio</td>
<td>یادداشت برداری با مارکداون</td>
<td>بهره‌وری</td>
</tr>
</tbody>
</table>
</body>
</html>
# کدام را انتخاب کنیم؟
<!DOCTYPE html>
<html lang="fa">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>ترجمه و مقایسه Gnome و Plasma</title>
<style>
table {
border-collapse: collapse;
width: 100%;
}
th, td {
padding: 8px;
text-align: center;
border: 1px solid #ddd;
}
th {
background-color: #f0f0f0;
}
</style>
</head>
<body>
<table>
<thead>
<tr>
<th>گنوم</th>
<th>پلاسما</th>
</tr>
</thead>
<tbody>
<tr>
<td>امکانات کمتر</td>
<td>امکانات بیشتر</td>
</tr>
<tr>
<td>بهتر - GTK</td>
<td>بهتر - QT</td>
</tr>
<tr>
<td>کمتر سفارشی سازی، اما ساده تر</td>
<td>قابلیت های بیشتر، اما یادگیری پیچیده تر</td>
</tr>
</tbody>
</table>

377
fa/contributing.md Normal file
View file

@ -0,0 +1,377 @@
---
title: مشارکت بر روی پروژه پارچ و پروژه‌های وابسته
description: راهنمای نحوه مشارکت بر روی پارچ
published: true
date: 2024-09-28T18:42:03.602Z
tags: پارچ, مشارکت
editor: markdown
dateCreated: 2024-09-28T09:49:13.655Z
---
# راهنمای کامل مشارکت در پروژه پارچ
**پروژه پارچ** به عنوان یک توزیع لینوکسی ایرانی، با هدف ارائه یک سیستم‌عامل کاربرپسند، پایدار، و امن برای کاربران ایرانی طراحی شده است. این توزیع بر اساس نیازهای خاص کاربران فارسی‌زبان ساخته شده و در تلاش است تا علاوه بر ارائه محیطی مناسب برای انجام فعالیت‌های روزمره مثل کارهای اداری، آموزشی و سرگرمی، به رشد جامعه فناوری متن‌باز در ایران نیز کمک کند.
پروژه پارچ بستری برای همکاری علاقه‌مندان به لینوکس و فناوری متن‌باز فراهم کرده تا بتوانند از طریق مشارکت در زمینه‌های مختلفی مثل **توسعه نرم‌افزار**، **مستندسازی**، **ترجمه**، **تست نرم‌افزار** و **مدیریت جامعه کاربران** به این توزیع کمک کنند. همکاری در این پروژه فرصتی عالی است تا علاوه بر کمک به بهبود و پیشرفت این توزیع، تجربه‌های ارزشمندی نیز در حوزه توسعه نرم‌افزار و مشارکت در پروژه‌های متن‌باز کسب کنید.
## چرا باید در پروژه پارچ مشارکت کنید؟
مشارکت در پروژه پارچ نه تنها باعث ارتقای مهارت‌های فنی و حرفه‌ای شما می‌شود، بلکه به شما این فرصت را می‌دهد که به عنوان بخشی از یک جامعه پویا و خلاق عمل کنید. این همکاری به توسعه و بهبود پارچ کمک می‌کند که می‌تواند تأثیر مستقیمی بر جامعه کاربران ایرانی داشته باشد. همچنین، پروژه‌های متن‌باز فضایی هستند که در آن‌ها می‌توانید با متخصصان این حوزه همکاری کرده و از آن‌ها بیاموزید.
### فرصت‌های مشارکت
در پروژه پارچ، فرصت‌های متنوعی برای مشارکت وجود دارد که در ادامه به تفصیل توضیح داده شده‌اند:
---
### ۱. توسعه نرم‌افزار
**اگر مهارت برنامه‌نویسی دارید، بخش توسعه نرم‌افزار پروژه پارچ، مکانی ایده‌آل برای شماست.**
در این بخش، توسعه‌دهندگان می‌توانند به بهبود کد پایه توزیع، نوشتن ابزارهای جدید یا رفع مشکلات موجود بپردازند. علاوه بر این، بهینه‌سازی سیستم‌عامل، بهبود عملکرد درایورها، و افزودن قابلیت‌های جدید به بسته‌های نرم‌افزاری از دیگر فعالیت‌های این حوزه است.
**مثال‌های عملی مشارکت در توسعه نرم‌افزار:**
- افزودن ویژگی‌های جدید به مدیر بسته‌ها (Package Manager).
- بهینه‌سازی عملکرد سیستم در مواجهه با سخت‌افزارهای مختلف.
- طراحی و توسعه ابزارهای کاربردی جدید برای کاربران.
**مهارت‌های مورد نیاز:**
- زبان‌های برنامه‌نویسی C، Python، Bash.
- آشنایی با سیستم‌عامل‌های لینوکسی و توسعه نرم‌افزارهای متن‌باز.
---
### ۲. مستندسازی
**مستندسازی یکی از بخش‌های کلیدی هر پروژه متن‌باز است و می‌تواند نقش مهمی در گسترش و پذیرش عمومی آن داشته باشد.**
مستندسازان می‌توانند به تهیه و نوشتن **راهنماهای کاربری**، **مستندات فنی**، و **آموزش‌ها** کمک کنند. همچنین نوشتن مقالات مرتبط با ویژگی‌های جدید یا تغییرات در نسخه‌های مختلف توزیع نیز از دیگر فعالیت‌های مرتبط با این حوزه است.
**مثال‌های عملی مشارکت در مستندسازی:**
- نوشتن راهنمای گام به گام نصب و استفاده از پارچ.
- تهیه مستندات فنی برای توسعه‌دهندگان، مانند مستندات API.
- ایجاد محتواهای آموزشی برای کاربران تازه‌وارد به لینوکس.
**مهارت‌های مورد نیاز:**
- تسلط به زبان فارسی و انگلیسی.
- مهارت نوشتن فنی و آشنایی با ساختار مستندات پروژه‌های متن‌باز.
---
### ۳. ترجمه
**یکی از اهداف پارچ، در دسترس قرار دادن نرم‌افزارها و مستندات برای کاربران فارسی‌زبان است. در این راستا، مترجمان نقش بسیار مهمی ایفا می‌کنند.**
شما می‌توانید به ترجمه مستندات، رابط‌های کاربری نرم‌افزارها، پیام‌های خطا و توضیحات مربوط به پروژه کمک کنید. این کار به کاربران فارسی‌زبان کمک می‌کند تا بتوانند به راحتی از سیستم‌عامل استفاده کنند و نیاز به تسلط کامل به زبان‌های دیگر نداشته باشند.
**مثال‌های عملی مشارکت در ترجمه:**
- ترجمه مستندات و راهنماهای کاربران به زبان فارسی.
- ترجمه رابط‌های کاربری نرم‌افزارها و بسته‌های مرتبط با توزیع پارچ.
- بومی‌سازی پیام‌های خطا و اعلان‌های سیستم برای کاربران ایرانی.
**مهارت‌های مورد نیاز:**
- تسلط کامل به زبان فارسی و انگلیسی.
- آشنایی با نرم‌افزارهای ترجمه و بومی‌سازی متن‌باز مانند **Poedit**.
---
### ۴. تست و بازخورد
**تست نرم‌افزارها و گزارش باگ‌ها یکی از مهم‌ترین مراحل توسعه یک سیستم‌عامل است.**
شما به عنوان تست‌کننده، می‌توانید نسخه‌های پیش‌نمایش و بتا را امتحان کنید و با بررسی عملکرد سیستم و نرم‌افزارها، مشکلات و باگ‌های موجود را گزارش دهید. این کار باعث می‌شود تا توزیع پایدارتر و قابل اعتمادتر شود.
**مثال‌های عملی مشارکت در تست:**
- نصب نسخه‌های آزمایشی توزیع پارچ و ارائه بازخورد در مورد عملکرد آن.
- تست ویژگی‌های جدید و گزارش مشکلات احتمالی به تیم توسعه.
- بررسی سازگاری سیستم با سخت‌افزارهای مختلف و گزارش نتایج.
**مهارت‌های مورد نیاز:**
- آشنایی با سیستم‌عامل لینوکس.
- توانایی شناسایی و گزارش مشکلات فنی.
---
### ۵. طراحی رابط کاربری
**طراحان گرافیک و تجربه کاربری نیز می‌توانند نقش مهمی در بهبود تجربه کاربری پارچ ایفا کنند.**
با طراحی رابط‌های گرافیکی زیبا و کاربرپسند، به کاربران کمک می‌کنید تا به راحتی با سیستم‌عامل ارتباط برقرار کنند و از کار با آن لذت ببرند. طراحی **آیکون‌ها**، **تم‌ها** و **صفحات ورود به سیستم** از جمله کارهایی است که در این بخش می‌توان انجام داد.
**مثال‌های عملی مشارکت در طراحی:**
- طراحی آیکون‌ها و تم‌های جدید برای سیستم.
- بهبود طراحی گرافیکی صفحات ورود و خروج به سیستم.
- طراحی پوسترها و تبلیغات گرافیکی برای معرفی توزیع.
**مهارت‌های مورد نیاز:**
- مهارت در ابزارهای طراحی مانند **Adobe Photoshop** یا **GIMP** برای طراحی پوستر و تصویر زمینه.
- مهارت در **inkscape** و **Adobe Illustrator** برای طراحی آیکون.
- مهارت در **penpot** و **Figma** برای طراحی رابط‌کاربری.
- آشنایی با مفاهیم تجربه کاربری (UX) و طراحی رابط کاربری (UI).
---
### ۶. آموزش و برگزاری کارگاه‌ها
**اگر تخصصی در زمینه لینوکس و فناوری‌های متن‌باز دارید، می‌توانید با برگزاری کارگاه‌های آموزشی به کاربران جدید کمک کنید.**
این کارگاه‌ها می‌توانند شامل آموزش‌هایی درباره نصب و پیکربندی سیستم‌عامل، استفاده از ابزارهای کاربردی، و یا مفاهیم پیشرفته‌تر مربوط به توسعه نرم‌افزار باشند.
**مثال‌های عملی مشارکت در آموزش:**
- برگزاری کارگاه‌های آنلاین یا حضوری برای آموزش نصب و استفاده از پارچ.
- تهیه ویدئوهای آموزشی در مورد ویژگی‌های جدید توزیع.
- برگزاری دوره‌های آموزشی برای آشنایی کاربران با مفاهیم پایه لینوکس.
**مهارت‌های مورد نیاز:**
- تخصص در سیستم‌عامل لینوکس و ابزارهای مرتبط.
- توانایی تدریس و انتقال مفاهیم به کاربران مبتدی.
---
### ۷. مدیریت جامعه کاربران
**مدیریت و ارتباط با کاربران یکی از بخش‌های حیاتی هر پروژه متن‌باز است.**
شما می‌توانید با مدیریت گروه‌های کاربری آنلاین، پاسخ به سوالات کاربران و ارائه محتوای آموزشی و پشتیبانی، به رشد جامعه کاربران پارچ کمک کنید. این بخش مناسب افرادی است که مهارت‌های ارتباطی قوی و علاقه‌مند به ایجاد تعاملات سازنده هستند.
**مثال‌های عملی مشارکت در مدیریت جامعه:**
- مدیریت گروه‌های کاربری در تلگرام، فروم‌های آنلاین یا شبکه‌های اجتماعی.
- پاسخ به سوالات کاربران و کمک به رفع مشکلات آن‌ها.
- ایجاد و انتشار محتوای آموزشی برای آشنایی بیشتر کاربران با توزیع.
**مهارت‌های مورد نیاز:**
- مهارت‌های ارتباطی و اجتماعی قوی.
- آشنایی با نیازها و سوالات رایج کاربران لینوکس.
---
### ۸. توسعه افزونه‌ها و نرم‌افزارهای جانبی
**ایجاد افزونه‌ها و نرم‌افزارهای جانبی جدید، یکی از بهترین روش‌ها برای افزایش کارایی و جذابیت یک توزیع لینوکسی است.**
توسعه‌دهندگان می‌توانند ابزارهای کاربردی جدید و افزونه‌های متنوعی را برای پارچ طراحی کنند که باعث بهبود تجربه کاربری و افزایش قابلیت‌های این توزیع شود.
**مثال‌های عملی مشارکت در توسعه افزونه‌ها:**
- طراحی و توسعه یک نرم‌افزار مدیریت فایل جدید برای پارچ.
- ایجاد افزونه‌های جدید برای بهبود تجربه کاربری.
- توسعه ابزارهای خط فرمان کاربردی برای کاربران حرفه‌ای.
ابزارهای خط فرمان کاربردی برای کاربران حرفه‌ای.
**مهارت‌های مورد نیاز:**
- زبان‌های برنامه‌نویسی مانند Python، Shell Scripting.
- آشنایی با مفاهیم توسعه افزونه و نرم‌افزارهای لینوکسی.
---
### ۹. توسعه وب
**توسعه وب، بخش مهمی از زیرساخت‌های یک پروژه متن‌باز است و شما می‌توانید به توسعه یا بهبود سایت پروژه پارچ کمک کنید.**
در این بخش، توسعه‌دهندگان وب می‌توانند به بهبود سایت رسمی پروژه، طراحی و توسعه **داشبوردهای مدیریتی** یا ایجاد **وب‌اپلیکیشن‌های جدید** کمک کنند. این همکاری می‌تواند شامل بهبود عملکرد، طراحی بهتر رابط کاربری یا ایجاد بخش‌های تعاملی جدید برای کاربران باشد.
**مثال‌های عملی مشارکت در توسعه وب:**
- طراحی و بهینه‌سازی وب‌سایت رسمی پارچ.
- توسعه پنل‌های مدیریتی برای مدیریت کاربران یا گزارش‌های باگ.
- بهینه‌سازی SEO وب‌سایت برای بهبود رتبه در موتورهای جستجو.
**مهارت‌های مورد نیاز:**
- آشنایی با HTML، CSS، JavaScript.
- تسلط به فریم‌ورک‌های JavaScript مانند React یا Vue.js.
- آشنایی با سیستم‌های مدیریت محتوا (CMS) مانند WordPress.
---
### ۱۰. امنیت و حریم خصوصی
**امنیت و حریم خصوصی بخش‌های حیاتی هر پروژه نرم‌افزاری است، مخصوصاً در دنیای متن‌باز که امنیت کد به طور عمومی قابل بررسی است.**
کارشناسان امنیتی می‌توانند به بهبود **امنیت هسته سیستم‌عامل**، بررسی کد برای کشف **آسیب‌پذیری‌ها**، و ارائه راهکارهایی برای بهبود **حریم خصوصی کاربران** کمک کنند. مشارکت در این زمینه از اهمیت بالایی برخوردار است، زیرا اعتماد کاربران به امنیت سیستم‌عامل نقشی کلیدی در موفقیت آن ایفا می‌کند.
**مثال‌های عملی مشارکت در امنیت:**
- بررسی کد برای کشف آسیب‌پذیری‌ها و حفره‌های امنیتی.
- بهبود تنظیمات پیش‌فرض امنیتی سیستم‌عامل.
- بررسی و بهینه‌سازی مکانیزم‌های مدیریت رمزگذاری و حریم خصوصی کاربران.
**مهارت‌های مورد نیاز:**
- تسلط به اصول امنیت اطلاعات.
- آشنایی با ابزارهای امنیتی مانند Wireshark و Metasploit.
- تجربه در تست نفوذ و رفع آسیب‌پذیری‌های امنیتی.
---
### ۱۱. مدیریت بسته‌ها و مخازن نرم‌افزاری
**مدیریت بسته‌ها (Package Management) و مخازن نرم‌افزاری، بخش مهمی از تجربه کاربری در توزیع‌های لینوکسی است.**
شما می‌توانید در این بخش به بهینه‌سازی **مدیر بسته‌ها**، مدیریت مخازن نرم‌افزاری، و همچنین کمک به توسعه **اسکریپت‌های خودکارسازی نصب بسته‌ها** بپردازید. این همکاری باعث می‌شود تا کاربران بتوانند به راحتی نرم‌افزارهای مورد نیاز خود را از طریق مخازن رسمی یا شخصی نصب و مدیریت کنند.
**مثال‌های عملی مشارکت در مدیریت بسته‌ها:**
- بهینه‌سازی مدیر بسته‌های سیستم و افزودن ویژگی‌های جدید.
- توسعه اسکریپت‌های خودکار برای نصب آسان بسته‌ها.
- مدیریت و نگهداری مخازن نرم‌افزاری برای اطمینان از سازگاری بسته‌ها با نسخه‌های جدید پارچ.
**مهارت‌های مورد نیاز:**
- آشنایی با سیستم‌های مدیریت بسته مانند APT، RPM یا Pacman.
- مهارت در زبان‌های برنامه‌نویسی Bash یا Python.
- توانایی ایجاد و نگهداری بسته‌های نرم‌افزاری لینوکسی.
---
### ۱۲. آزمایشگاه مجازی و زیرساخت‌های ابری
**در توسعه پروژه‌های بزرگ و متن‌باز، ایجاد زیرساخت‌های آزمایشگاهی و مجازی نقش مهمی ایفا می‌کند.**
کاربرانی که در حوزه **مجازی‌سازی** و **زیرساخت‌های ابری** تخصص دارند، می‌توانند به ایجاد محیط‌های آزمایشی برای تست نسخه‌های مختلف پارچ یا توسعه **زیرساخت‌های ابری** برای ارائه سرویس‌های لینوکسی به کاربران کمک کنند.
**مثال‌های عملی مشارکت در زیرساخت‌ها:**
- راه‌اندازی آزمایشگاه‌های مجازی برای تست نسخه‌های جدید پارچ.
- توسعه سرویس‌های مبتنی بر **ابر** برای کاربران و توسعه‌دهندگان.
- بهبود زیرساخت‌های توزیع برای نصب و تست در محیط‌های مختلف.
**مهارت‌های مورد نیاز:**
- تسلط به مجازی‌سازی با استفاده از **KVM**، **VirtualBox** یا **Docker**.
- آشنایی با پلتفرم‌های ابری مانند **AWS**، **Google Cloud** یا **OpenStack**.
- آشنایی با سیستم‌های مدیریت زیرساخت و خودکارسازی.
---
### ۱۳. تحلیل عملکرد و بهینه‌سازی سیستم
**یکی دیگر از زمینه‌های کلیدی برای مشارکت، تحلیل عملکرد سیستم و بهینه‌سازی آن است.**
این بخش مناسب افرادی است که علاقه به تحلیل داده‌های عملکردی و بهبود کارایی سیستم دارند. شما می‌توانید با استفاده از ابزارهای **پروفایلینگ** و **مانیتورینگ** به شناسایی نقاط ضعف عملکردی سیستم بپردازید و پیشنهادهایی برای بهبود کارایی ارائه کنید.
**مثال‌های عملی مشارکت در بهینه‌سازی سیستم:**
- مانیتورینگ عملکرد سیستم و شناسایی منابع مصرف زیاد.
- بهینه‌سازی مصرف منابع سیستم در هنگام استفاده از نرم‌افزارهای سنگین.
- تحلیل داده‌های لاگ و ارائه پیشنهادات برای بهبود کارایی.
**مهارت‌های مورد نیاز:**
- آشنایی با ابزارهای پروفایلینگ مانند **Perf** و **Valgrind**.
- توانایی تحلیل داده‌های سیستم و ارائه راه‌حل‌های بهینه‌سازی.
- تجربه در بهبود کارایی و مصرف منابع سیستم‌های لینوکسی.
---
### ۱۴. توسعه ابزارهای DevOps و CI/CD
**استفاده از ابزارهای خودکارسازی (DevOps) و روش‌های Continuous Integration/Continuous Delivery (CI/CD) به توسعه سریع‌تر و موثرتر پروژه کمک می‌کند.**
شما می‌توانید به ایجاد و نگهداری **پایپ‌لاین‌های CI/CD** برای تست و ارائه نسخه‌های جدید، توسعه **اسکریپت‌های خودکار** برای به‌روزرسانی بسته‌ها و پیکربندی سرورها، و بهبود فرآیندهای انتشار و استقرار پروژه کمک کنید.
**مثال‌های عملی مشارکت در DevOps:**
- طراحی و پیاده‌سازی پایپ‌لاین‌های CI/CD برای تست و استقرار خودکار نسخه‌ها.
- خودکارسازی فرآیندهای تست و بررسی کد قبل از ادغام با نسخه اصلی.
- نگهداری سرورهای توزیع و به‌روزرسانی بسته‌های نرم‌افزاری.
**مهارت‌های مورد نیاز:**
- آشنایی با ابزارهای CI/CD مانند **Jenkins**، **GitLab CI** یا **CircleCI**.
- مهارت در اسکریپت‌نویسی با Bash، Python، یا Ansible.
- توانایی مدیریت سرورها و زیرساخت‌های خودکارسازی.
---
### ۱۵. توسعه و بهبود سیستم‌های هوش مصنوعی و یادگیری ماشین
**با توجه به اهمیت روزافزون هوش مصنوعی (AI) و یادگیری ماشین (ML)، شما می‌توانید با توسعه ابزارها و الگوریتم‌های هوش مصنوعی به پروژه پارچ کمک کنید.**
این همکاری می‌تواند شامل پیاده‌سازی الگوریتم‌های **یادگیری ماشین** برای بهبود عملکرد سیستم، تحلیل داده‌ها یا ایجاد ابزارهای جدید برای کاربران باشد. توسعه‌دهندگان در این بخش می‌توانند ابزارهای مبتنی بر هوش مصنوعی را برای استفاده در سیستم‌عامل لینوکسی بهبود دهند.
**مثال‌های عملی مشارکت در AI/ML:**
- توسعه الگوریتم‌های یادگیری ماشین برای بهبود عملکرد سیستم.
- ایجاد ابزارهای هوشمند برای تحلیل داده‌های کاربران.
- بهینه‌سازی فرآیندهای مرتبط با هوش مصنوعی و پیاده‌سازی آن‌ها در توزیع پارچ.
**مهارت‌های مورد نیاز:**
- آشنایی با الگوریتم‌های یادگیری ماشین و زبان‌های برنامه‌نویسی مرتبط (Python، R).
- تجربه کار با فریم‌ورک‌های ML مانند **TensorFlow**، **PyTorch**.
- آشنایی با تحلیل داده‌ها و استفاده از مدل‌های هوش مصنوعی در سیستم‌های لینوکسی.
---
### ۱۶. توسعه نسخه‌های ایموتبل (Immutable)
**نسخه‌های ایموتبل** به عنوان یک نوع سیستم‌عامل که تغییرات غیرقابل برگشت در فایل‌های سیستمی ندارد، محبوبیت بیشتری پیدا کرده‌اند. در این نسخه‌ها، سیستم‌عامل به گونه‌ای طراحی شده که کاربران نمی‌توانند فایل‌های سیستمی را تغییر دهند و این باعث افزایش **امنیت** و **پایداری** سیستم می‌شود.
پروژه پارچ می‌تواند از نسخه‌های ایموتبل بهره‌مند شود تا برای کاربران **محیط‌های ایزوله و امن** فراهم کند. شما می‌توانید با مشارکت در توسعه این نسخه‌ها و بهینه‌سازی آن‌ها برای کاربران حرفه‌ای‌تر یا کسب‌وکارها، به ایجاد یک سیستم‌عامل مقاوم در برابر تغییرات ناخواسته کمک کنید.
**مثال‌های عملی مشارکت در نسخه‌های ایموتبل:**
- پیاده‌سازی سیستم‌های مبتنی بر **OSTree** یا **Btrfs** برای ایجاد نسخه‌های ایموتبل.
- بهینه‌سازی کارایی و سرعت نسخه‌های ایموتبل برای نصب سریع و استفاده در محیط‌های تولید.
- طراحی **سندباکس‌ها** و **سیستم‌های کانتینری** برای مدیریت نرم‌افزارهای جداگانه.
**مهارت‌های مورد نیاز:**
- آشنایی با فایل‌سیستم‌های Btrfs و OSTree.
- تجربه در مدیریت سیستم‌های ایموتبل و بهینه‌سازی آن‌ها.
- مهارت در توسعه و استفاده از ابزارهای **کانتینرها** مانند Docker و Podman.
---
### ۱۷. نسخه‌های جامعه‌محور
**نسخه‌های جامعه‌محور** در پروژه‌هایی مانند **مانجارو** نشان داده‌اند که چگونه می‌توان جامعه کاربران را به بخشی فعال از فرآیند توسعه و انتشار تبدیل کرد. در پروژه پارچ نیز می‌توان از این الگو برای ایجاد نسخه‌هایی که توسط جامعه کاربران پشتیبانی و توسعه داده می‌شوند، استفاده کرد.
این نسخه‌ها می‌توانند شامل **نسخه‌های تخصصی** با **محیط‌های دسکتاپ مختلف** یا **ابزارهای خاص** باشند که نیازهای گروه‌های خاصی از کاربران را پوشش دهند. شما می‌توانید با همکاری در توسعه این نسخه‌ها و انتشار آن‌ها در کنار نسخه اصلی پارچ، به کاربران انعطاف بیشتری در انتخاب نسخه مناسب کمک کنید.
**مثال‌های عملی مشارکت در نسخه‌های جامعه‌محور:**
- توسعه نسخه‌های تخصصی پارچ برای محیط‌های کاری خاص (مثلاً نسخه‌های مخصوص توسعه‌دهندگان یا هنرمندان).
- پشتیبانی از محیط‌های دسکتاپ مختلف مانند **KDE**، **XFCE**، یا **GNOME**.
- ایجاد نسخه‌هایی با ابزارهای خاص برای مدیریت سرورها یا توسعه نرم‌افزار.
**مهارت‌های مورد نیاز:**
- تجربه در استفاده و مدیریت توزیع‌های لینوکسی با محیط‌های دسکتاپ مختلف.
- آشنایی با مدیریت مخازن نرم‌افزاری و سیستم‌های انتشار.
- توانایی توسعه و نگهداری نسخه‌های مستقل از توزیع پارچ.
---
### ۱۸. انتشار نسخه‌های سبک (Lite)
**نسخه‌های سبک** که به کاربران اجازه می‌دهند از سیستم‌عامل با حداقل منابع سخت‌افزاری استفاده کنند، در بسیاری از توزیع‌های لینوکسی محبوب شده‌اند. این نسخه‌ها به ویژه برای دستگاه‌های قدیمی یا کاربرانی که به دنبال عملکرد سریع و سبک هستند، مفید هستند.
پروژه پارچ می‌تواند با انتشار نسخه‌های **Lite** برای کاربرانی که نیاز به سیستم‌عاملی با مصرف کم منابع دارند، تجربه کاربری بهینه‌ای را فراهم کند. شما می‌توانید با کاهش اندازه بسته‌ها، بهینه‌سازی محیط دسکتاپ و حذف نرم‌افزارهای غیرضروری، به توسعه این نسخه کمک کنید.
**مثال‌های عملی مشارکت در نسخه‌های Lite:**
- بهینه‌سازی سیستم برای استفاده در دستگاه‌های کم‌مصرف مانند لپ‌تاپ‌های قدیمی یا Raspberry Pi.
- کاهش اندازه فایل‌های سیستمی و حذف نرم‌افزارهای غیرضروری برای افزایش سرعت و کاهش مصرف منابع.
- بهبود عملکرد درایورها و سرویس‌های پس‌زمینه برای عملکرد بهتر سیستم در شرایط محدود.
**مهارت‌های مورد نیاز:**
- آشنایی با سیستم‌های بهینه‌سازی لینوکس و کاهش مصرف منابع.
- توانایی ایجاد نسخه‌های کوچک‌تر از توزیع برای استفاده در دستگاه‌های ضعیف‌تر.
- مهارت در محیط‌های دسکتاپ سبک مانند **LXDE** یا **XFCE**.
---
### ۱۹. سیستم‌های بازیابی و نسخه‌های زنده (Live)
**نسخه‌های زنده (Live)** به کاربران این امکان را می‌دهند که بدون نصب سیستم‌عامل، به صورت زنده از آن استفاده کنند. این نسخه‌ها به ویژه برای **آزمایش سیستم‌عامل**، **بازیابی اطلاعات** یا **عیب‌یابی** بسیار مفید هستند.
شما می‌توانید در توسعه نسخه‌های زنده پارچ کمک کرده و سیستم‌های **بازیابی** و **عیب‌یابی** ایجاد کنید که برای کاربران در زمان‌های بحرانی مفید باشند. این نسخه‌ها می‌توانند به گونه‌ای طراحی شوند که به کاربران اجازه دهند سیستم خود را بدون نیاز به نصب کامل سیستم‌عامل بازیابی کنند.
**مثال‌های عملی مشارکت در نسخه‌های زنده و بازیابی:**
- ایجاد ابزارهای بازیابی و تعمیر سیستم در نسخه‌های زنده برای حل مشکلات کاربرانی که با خطاهای سیستمی مواجه می‌شوند.
- بهینه‌سازی ابزارهای بازیابی اطلاعات و پشتیبان‌گیری برای کاربران عادی و حرفه‌ای.
**مهارت‌های مورد نیاز:**
- آشنایی با ساخت نسخه‌های زنده لینوکسی.
- توانایی ایجاد ابزارهای بازیابی و پشتیبان‌گیری برای استفاده در نسخه‌های زنده.
- مهارت در مدیریت فایل‌سیستم‌ها و بهینه‌سازی ابزارهای عیب‌یابی.
---
### ۲۰. توسعه و مدیریت نسخه‌های سرور
پروژه پارچ می‌تواند با ارائه نسخه‌های **مخصوص سرور**، به کسب‌وکارها و متخصصان فناوری اطلاعات کمک کند تا یک سیستم‌عامل پایدار و امن برای مدیریت سرورها داشته باشند. این نسخه‌ها معمولاً بدون محیط دسکتاپ هستند و برای اجرا در **دیتاسنترها** یا **ابر** بهینه شده‌اند.
شما می‌توانید در توسعه و بهینه‌سازی این نسخه‌ها برای محیط‌های **سرور**، **کلود** و **میزبانی وب** مشارکت کنید. همچنین توسعه ابزارهای مدیریت و نظارت بر سرورهای لینوکسی می‌تواند بخشی از این فعالیت باشد.
**مثال‌های عملی مشارکت در نسخه‌های سرور:**
- توسعه نسخه‌ای از پارچ برای استفاده به عنوان سیستم‌عامل سرور بدون محیط دسکتاپ.
- بهینه‌سازی ابزارهای مدیریت سرور و اسکریپت‌های خودکارسازی.
- افزودن بسته‌های مخصوص مدیریت و نظارت بر دیتاسنترها و کلود.
**مهارت‌های مورد نیاز:**
- آشنایی با سیستم‌های مدیریت سرورهای لینوکسی و اسکریپت‌نویسی.
- توانایی مدیریت و بهینه‌سازی زیرساخت‌های ابری و دیتاسنترها.
- تجربه کار با ابزارهای مانیتورینگ و مدیریت منابع سرور.
---
## چگونگی شروع مشارکت در پروژه پارچ
برای شروع مشارکت در پروژه پارچ، می‌توانید از مراحل زیر استفاده کنید:
1. **ثبت‌نام و پیوستن به جامعه کاربران**: با عضویت در گروه و یا فروم پارچ می‌توانید عضوی از جامعه کاربری پارچ باشید.
2. **انتخاب حوزه مشارکت**: پس از آشنایی با پروژه، زمینه مورد علاقه خود را انتخاب کرده و شروع به کار کنید.
3. **همکاری با تیم توسعه**: با اعضای دیگر تیم توسعه در تماس باشید، مشکلات را گزارش دهید و به تبادل نظر بپردازید.
4. **ارائه بازخورد و پیشنهادات**: بازخوردهای خود را با تیم پروژه در میان بگذارید تا به بهبود و رشد توزیع کمک کنید.
---
**آدرس‌های مرتبط:**
- **سایت رسمی پارچ:** [parchlinux.com](#)
- **گروه تلگرام کاربران پارچ:** [t.me/parchlinux_fa](#)
- **فروم رسمی کاربران پارچ:** [forum.parchlinux.com](#)
- **گیت‌لب پارچ:** [git.parchlinux.com](#)

89
fa/debian-chroot.md Normal file
View file

@ -0,0 +1,89 @@
---
title: chroot دبیان در پارچ لینوکس
description:
published: true
date: 2024-04-05T14:06:30.798Z
tags:
editor: markdown
dateCreated: 2024-04-05T13:51:42.264Z
---
# chroot چیست؟
ابزار لینوکس chroot می تواند دایرکتوری روت درحال کار را برای یک فرآیند تغییر دهد و دسترسی به بقیه فایل سیستم را محدود کند.
## چگونه chroot دبیان را داخل پارچ لینوکس داشته باشیم؟
1. Debootstrap را نصب کنید
```bash
sudo pacman -Sy
sudo pacman -S debootstrap
```
2. یک پوشه جدید داخل /opt دبیان خود بسازید
```bsah
sudo mkdir /opt/debian
```
3. مکان Debootstrap را تنظیم کنید و Debootstraping را شروع کنید
```bash
DEBOOTSTRAP_DIR=/opt/debootstrap/usr/share/debootstrap /opt/debootstrap/usr/sbin/debootstrap --arch amd64 bookworm /opt/debian/ http://ftp.uk.debian.org/debian/
```
- توجه: می توانید نسخه دبیان را با تغییر bookworm به کد نام دبیان خود تغییر دهید. در [اینجا](https://wiki.debian.org/DebianReleases#Production_Releases) می توانید کدهای اسم دبیان را پیدا کنید.
4. ماونت دایرکتوری ها
```bash
mount -t proc proc /opt/debian/proc/
mount -t sysfs sys /opt/debian/sys/
mount -o bind /dev /opt/debian/dev/
mount -o bind /dev/pts /opt/debian/dev/pts/
```
5. تنظیم مخازن برای سیستم chroot شده ی شما
```bash
cat > /opt/debian/etc/apt/sources.list << 'EOF'
deb http://ftp.uk.debian.org/debian/ bookworm main non-free contrib
deb-src http://ftp.uk.debian.org/debian/ bookworm main non-free contrib
deb http://security.debian.org/ bookworm/updates main non-free contrib
deb-src http://security.debian.org/ bookworm/updates main non-free contrib
deb http://ftp.uk.debian.org/debian/ bookworm-updates main non-free contrib
deb-src http://ftp.uk.debian.org/debian/ bookworm-updates main non-free contrib
EOF
```
- توجه: کد نام را به نسخه نصب شده خود تغییر دهید
6. به دبیان خود chroot بزنید
```bash
chroot /opt/debian /bin/bashchroot /opt/debian /bin/bash
```
7. دبیان خود را بروز کنید و مکان ها را بازسازی کنید
```bash
apt-get update && apt-get dist-upgrade
apt-get install locales
dpkg-reconfigure locales
```
8. یک اسم به /etc/hosts اضافه کنید
```bash
echo mywonderfulldebian >> /etc/hosts
```
## اختیاری
1. یک کاربر جدید به chroot اضافه کنید
```bash
apt-get install curl sudo ncurses-term
groupadd sudo
useradd -m -G sudo -s /bin/bash parch
passwd parch
```
- توجه: نام کاربری خود را جایگزین parch کنید
2. کاربر جدید به sudoers اضافه کنید
```bash
cat > /etc/sudoers << 'EOF'
root ALL=(ALL) ALL
%sudo ALL=(ALL) ALL
EOF
```
3. به کاربر خود متصل شوید
```bash
sudo -iu parch
```
یا
```bash
su parch
```

2259
fa/dictionary.md Normal file

File diff suppressed because it is too large Load diff

150
fa/gnome.md Normal file
View file

@ -0,0 +1,150 @@
---
title: گنوم
description:
published: false
date: 2024-11-21T18:24:57.561Z
tags: پارچ, گنوم
editor: markdown
dateCreated: 2024-11-20T15:39:31.166Z
---
# گنوم چیست؟
> گنوم (/(ɡ)noʊm/) یک محیط میزکار است که هدف سادگی و آسان بودن برای استفاده کردن است. It is designed by The GNOME Project and is composed entirely of free and open-source software.
### اسکرین‌شات از گنوم در پارچ لینوکس
![screenshot](https://github.com/parchlinux/Parch-iso-gnome/raw/main/image/screenshot.png)
## مهاجرت از میزکارهای دیگر به گنوم
برای نصب گنوم روی پارچ لینوکس، شما باید متاپکیچ ما را نصب کنید:
```bash
sudo pacman -S parch-gnome-meta
```
این یک نشست گنوم مینیمال با شخصی‌سازی پارچ، روی پارچ لینوکس نصب می‌کند.
### فعال‌کردن مدیر نمایش
if you are moving from KDE or other desktops (به‌صورت پیش فرض پارچ در تمامی نسخه‌ها از sddm استفاده می‌کند به جز گنوم) you need to disable your old login manager and then enable GDM .
```bash
# disabling old login manager (sddm)
sudo systemctl disable sddm
#enabling GDM
sudo systemctl enable gdm
```
## نکات و ترفندها
### فعال‌سازی نامبرلاک در میزکار گنوم
برای فعال‌سازی این رفتار، این دستور را در ترمینال وارد کنید:
```bash
gsettings set org.gnome.desktop.peripherals.keyboard numlock-state true
```
برای اینکه گنوم، هربار فعال یا فعال نبودن را به خاطر بسپارد:
```bash
gsettings set org.gnome.desktop.peripherals.keyboard remember-numlock-state true
```
### هدایت پیوندهای خاص به مرورگرهای خاصی
This shows how to use Chromium for certain types of URLs while maintaining Firefox as default browser for all other tasks.
مطمئن شوید برای استفاده از `pcregrep` بسته `pcre` نصب شده است.
تنظیم xdg-open سفارشی:
```
/usr/local/bin/xdg-open
```
```
#!/bin/bash
DOMAIN_LIST_FILE=~/'domains.txt'
OTHER_BROWSER='/usr/bin/chromium-browser'
BROWSER_OPTIONS='' # Optional, for command line options passed to browser
XDG_OPEN='/usr/bin/xdg-open'
DEFAULT_BROWSER='/usr/bin/firefox'
if echo "$1" | pcregrep -q '^https?://'; then
matching=0
while read domain; do
if echo "$1" | pcregrep -q "^https?://${domain}"; then
matching=1
break
fi
done < "$DOMAIN_LIST_FILE"
if [[ $matching -eq 1 ]]; then
"$OTHER_BROWSER" $BROWSER_OPTIONS ${*}
exit 0
fi
"$DEFAULT_BROWSER" ${*}
exit 0
else
"$XDG_OPEN" ${*}
fi
```
کانفیگ کردن دامنه‌ها برای هدایت شدن به کرومیوم:
```
$HOME/domains.txt
```
```
stackexchange.com
stackoverflow.com
superuser.com
www.youtube.com
github.com
```
تنظیم xdg-open web به عنوان برنامه میزکار:
```
$HOME/.local/share/applications/xdg-open-web.desktop
```
```
[Desktop Entry]
Version=1.0
Name=xdg-open web
GenericName=Web Browser
Exec=xdg-open %u
Terminal=false
Type=Application
MimeType=text/html;text/xml;application/xhtml+xml;application/vnd.mozilla.xul+xml;text/mml;x-scheme-handler/http;x-scheme-handler/https;
StartupNotify=true
Categories=Network;WebBrowser;
Keywords=web;browser;internet;
Actions=new-window;new-private-window;
```
```
$ update-desktop-database $HOME/.local/share/applications/
```
Set xdg-open web as default Web application in GNOME settings: Go to GNOME Settings > Details > Default Applications and set Web to xdg-open web
### نشست های سفارشی گنوم
ایجاد نشست‌های سفارشی گنوم که از مدیر نشست گنوم استفاده می‌کنند اما مجموعه‌های مختلفی از اجزاء را شروع می‌کنند؛ ممکن است. (برای مثال `Openbox` با `tint2` به جای `GNOME Shell`).
Two files are required for a custom GNOME session: a session file in ```/usr/share/gnome-session/sessions/``` which defines the components to be started and a desktop entry in `/usr/share/xsessions` which is read by the display manager. یک نمونه فایل نشست در زیر ارائه داده شده است:
```
/usr/share/gnome-session/sessions/gnome-openbox.session
```
```
[GNOME Session]
Name=GNOME Openbox
RequiredComponents=openbox;tint2;gnome-settings-daemon;
```
و یک نمونه فایل دسکتاپ:
```
/usr/share/xsessions/gnome-openbox.desktop
```
```
[Desktop Entry]
Name=GNOME Openbox
Exec=gnome-session --session=gnome-openbox
```

19
fa/home.md Normal file
View file

@ -0,0 +1,19 @@
---
title: خانه
description:
published: true
date: 2024-12-26T13:44:27.086Z
tags:
editor: markdown
dateCreated: 2024-04-05T13:21:21.206Z
---
# به ویکی پارچ لینوکس خوش آمدید!
این ویکی رسمی پارچ لینوکس است.
شما می توانید **راه حلی برای مشکلات خود** بیابید و همچنین چیزهای جدیدی یاد بگیرید.
برای مشارکت در تکمیل ویکی می‌توانید با رایانامه [behdanisohrab@riseup.net](mailto:behdanisohrab@riseup.net) در ارتباط باشید.

106
fa/neovim.md Normal file
View file

@ -0,0 +1,106 @@
---
title: NeoVim به عنوان IDE
description: معرفی NeoVim همراه با چگونگی به‌کارگیری NeoVim مانند IDE های محبوب
published: true
date: 2025-02-18T17:02:26.296Z
tags: ide, vim, neovim, ویم, nvim, نئوویم
editor: markdown
dateCreated: 2025-02-08T12:37:50.156Z
---
# نئوویم
## معرفی
نئوویم یک انشعاب از ویم با یک سری اضافات است که در تلاش است تا توسعه پذیری و قابلیت نگهداری ویم را بهبود بخشد. نئوویم از همان نحو پیکربندی ویم پیروی می‌کند؛ بنابراین یک فایل پیکربندی مشابه را می‌توان با هر دو ویرایشگر استفاده کرد، اگرچه تفاوت‌های جزئی در جزئیات گزینه‌ها وجود دارد. اگر از ویژگی‌های اضافه شده نئوویم استفاده نشود، نئوویم تقریباً با تمام ویژگی‌های Vim سازگار است.
پروژهٔ نئوویم در سال ۲۰۱۴ و با تلاش برخی از اعضای انجمن ویم انجام شد که با استفاده از بازسازی سطح بالا، به هدف‌هایی از جمله ارائه نویسه‌ها و پلاگین‌های قدرتمندتر و همچنین ادغام بهتر با رابط‌های کاربری گرافیکی دست پیدا کنند. این پروژه نرم‌افزار آزاد است و کد منبع آن در GitHub موجود است. (مخزن در گیت‌هاب: https://github.com/neovim/neovim)
## نصب
نئوویم به راحتی با دستور زیر قابل نصب است:
```bash
sudo pacman -S neovim
```
> نئوویم با نام `neovim` نصب می‌شود ولی با دستور `nvim` می‌توان آن را اجرا نمود
## تبدیل نئوویم به IDE
نئوویم به تنهایی ابزار های لازم برای توسعه‌دهندگان را ندارد، به همین دلیل با به‌کارگیری افزونه‌های موجود آن را مشابه IDE های موجود میکنیم. برای این کار دو روش پیش رو داریم.
### 1. **کانفیگ‌های موجود**
برای کاربرانی که می‌خواهند به سرعت یک محیط توسعه قدرتمند برسند، به‌کارگیری کانفیگ‌های از پیش موجود بهترین گزینه است. برخی از محبوب‌ترین کانفیگ‌ها عبارتند از:
#### **AstroNvim**
AstroNvim یک پیکربندی نئوویم زیبا و غنی از ویژگی است که بر کارایی و توسعه‌پذیری تمرکز دارد. برای نصب آن [راهنمای رسمی AstroNvim](https://docs.astronvim.com/) را دنبال کنید.
#### **NVChad**
NVChad یک کانفیگ محبوب برای نئوویم است که به کاربران اجازه می‌دهد تا به راحتی آن را شخصی‌سازی کنند. برای نصب آن [راهنمای رسمی NVChad](https://nvchad.com/docs/quickstart/install) را دنبال کنید
### 2. **تنظیم از صفر**
برای تبدیل نئوویم به یک IDE، می‌توانید افزونه‌های لازم را خودتان یک به یک نصب کنید. این روش برای کاربرانی مناسب است که می‌خواهند تنظیمات خود را به طور کامل کنترل کنند. برای این کار نیاز به یک مدیر افزونه دارید تا دیگر افزونه های شما را مدیریت کند. یکی از محبوب ترین مدیر بسته‌های موجود [lazy.nvim](https://www.lazyvim.org/) است.
#### نصب مدیر افزونه `lazy.nvim`:
1. برای نصب lazy.nvim آن را با گیت دریافت کنید:
```bash
git clone https://github.com/LazyVim/starter ~/.config/nvim
```
2. پس از نصب، پوشه `.git` را پاک کنید:
```bash
rm -rf ~/.config/nvim/.git
```
3. می‌توانید آن را با دستور `nvim` اجرا کنید، حالا نیاز به نصب افزونه‌ها دارید. برخی از افزونه‌های پرکاربرد مانند:
- **LSP**: `nvim-lspconfig`
- **تکمیل خودکار**: `nvim-cmp`
- **مدیر پروژه**: `project.nvim`
- **مدیر فایل**: `nvim-tree.lua`
#### نمونه کانفیگ:
```lua
require("lazy").setup({
{
"folke/tokyonight.nvim", -- Theme
lazy = false,
priority = 1000,
config = function()
vim.cmd([[colorscheme tokyonight]])
end,
},
"neovim/nvim-lspconfig", -- LSP
"hrsh7th/nvim-cmp", -- Autocompletion
"nvim-tree/nvim-tree.lua", -- File explorer
"mbbill/undotree", -- Undo history
})
})
```
> برای نصب با این روش میتوانید [راهنمای رسمی lazy.nvim](https://www.lazyvim.org/) را دنبال کنید.
{.is-info}
## NeoVide
[NeoVide](https://neovide.dev/) یک رابط کاربری گرافیکی برای نئوویم است که مانند یک پایانه(Terminal) عادی عمل میکند که ویژگی‌های بیشتری برای NeoVim دارد.
#### ویژگی‌ها
- **Ligatures**: پشتیبانی از جفت‌نویسی(ligatures) و شکل‌دهی قلم برای بهبود ظاهر کد ها.
- **Animated Cursor**: پویانمایی اشاره‌گر(cursor) که موقعیت اشاره‌گر را قابل دنبال کردن‌تر می‌کند.
- **Smooth Scrolling**: بالا و پایین رفتن صفحه به جای حرکت خط به خط، پیکسل به پیکسل پویانمایی می‌شود، که تجربه کاربری را روان‌تر می‌کند.
- **Blurred Floating Windows**: پس‌زمینه پنجره‌های شناور با جلوه محو پس‌زمینه بهتر از صفحه اصلی جدا میشوند.
- **Emoji Support**: پشتیبانی از نمایش اموجی‌ها حتی اگر قلم اصلی شامل آن‌ها نباشد
نصب:
```bash
sudo pacman -S neovide
```
## فروشگاه افزونه
احتمالا تمام IDEهایی که تا به حال با آنها کار کرده‌اید برای نصب افزونه یک فروشگاه رسمی داشته‌اند، ولی در نئوویم چیزی به نام فروشگاه رسمی وجود ندارد، برای پیدا کردن افزونه‌ها میتوانید در اینترنت جستجو کرده و آموزش نصب هر افزونه را دنبال کنید و یا در منابع غیررسمی بگردید.اینها چند نمونه فهرست مردمی از افزونه‌های نئوویم را آورده‌ایم:
- https://github.com/rockerBOO/awesome-neovim
- https://neovimcraft.com/
- https://vimawesome.com/

209
fa/packaging-guideline.md Normal file
View file

@ -0,0 +1,209 @@
---
title: راهنمای بسته‌بندی برای توسعه‌دهندگان
description:
published: true
date: 2024-11-22T10:28:35.788Z
tags:
editor: markdown
dateCreated: 2024-11-22T10:28:31.070Z
---
## **راهنمای جامع بسته‌بندی در پارچ لینوکس**
### **1. مقدمه**
> این راهنما طراحی شده است تا استانداردهای لازم برای بسته‌بندی تمامی انواع نرم‌افزارها، ابزارها، فونت‌ها، برنامه‌های Wine و حتی برنامه‌های اندرویدی قابل اجرا در Waydroid را در توزیع پارچ لینوکس پوشش دهد. هدف ما ایجاد یکنواختی، پایداری، و کیفیت در بسته‌ها است.
---
### **2. پیش‌نیازها**
#### **ابزارهای اصلی ساخت بسته**
1. **ابزارهای ضروری:**
- `base-devel`: شامل ابزارهایی مانند `gcc`, `make`, `patch`.
- `git`: برای دریافت سورس‌ها از مخازن.
- `waydroid` (برای تست برنامه‌های اندرویدی، در صورت نیاز).
2. **ابزارهای خاص:**
- **برای Wine:** نصب `wine` و `winetricks`.
- **برای Waydroid:** نصب Waydroid از مخازن رسمی (یا AUR).
3. **ساختار فایل PKGBUILD:**
فایل PKGBUILD باید در بالاترین سطح شامل متغیرهای زیر باشد:
- نام بسته (`pkgname`)، نسخه (`pkgver`)، شماره انتشار (`pkgrel`)، معماری (`arch`).
- وابستگی‌ها (`depends`, `makedepends`)، لایسنس، توضیحات، و سورس.
#### **آشنایی با استاندارد FHS**
فایل‌ها باید طبق استاندارد **Filesystem Hierarchy Standard (FHS)** در مسیرهای مناسب قرار گیرند:
- **باینری‌ها:** `/usr/bin`
- **کتابخانه‌ها:** `/usr/lib` یا `/usr/lib64`
- **فونت‌ها:** `/usr/share/fonts/<نوع>`
- **داده‌های عمومی:** `/usr/share/<نام‌بسته>`
- **پیکربندی‌ها:** `/etc/<نام‌بسته>`
---
### **3. ساختار کلی PKGBUILD**
برای تمامی بسته‌ها، فایل PKGBUILD باید شامل این متغیرها باشد:
```bash
pkgname=<نام بسته>
pkgver=<نسخه>
pkgrel=<شماره انتشار>
pkgdesc="<توضیح مختصر بسته>"
arch=('x86_64' 'armv7h' 'aarch64') # یا هر معماری پشتیبانی‌شده
url="<آدرس پروژه>"
license=('GPL' 'MIT' 'custom')
depends=('فهرست بسته‌های وابسته')
makedepends=('فهرست ابزارهای لازم برای ساخت')
source=("آدرس سورس کد یا فایل")
sha256sums=('چک‌سام فایل‌ها')
```
---
### **4. بسته‌بندی فونت‌ها**
#### **قواعد نام‌گذاری:**
- **TrueType:** `ttf-fontname`
- **OpenType:** `otf-fontname`
- **Bitmap:** `bdf-fontname`
#### **مثال کامل برای فونت TrueType:**
بسته‌بندی فونت DejaVu:
```bash
pkgname=ttf-dejavu
pkgver=2.37
pkgrel=1
arch=('any')
pkgdesc="فونت‌های DejaVu با پشتیبانی گسترده."
license=('custom:Bitstream Vera')
source=("https://sourceforge.net/projects/dejavu/files/dejavu/${pkgver}/dejavu-fonts-ttf-${pkgver}.tar.bz2")
sha256sums=('fa9ca4efc0e2907e723aad11dc8f71c1f7b79be15f4f9b2c1214eeeaefa0f4dd')
package() {
cd "${srcdir}/dejavu-fonts-ttf-${pkgver}"
install -dm755 "${pkgdir}/usr/share/fonts/ttf-dejavu"
install -m644 ttf/*.ttf "${pkgdir}/usr/share/fonts/ttf-dejavu/"
}
```
#### **تست و فعال‌سازی فونت:**
- پس از نصب بسته، اطمینان حاصل کنید که فایل‌های فونت با دستور `fc-cache` در دسترس هستند:
```bash
post_install() {
fc-cache -f
}
```
---
### **5. بسته‌بندی برنامه‌های Wine**
#### **قواعد خاص برای Wine:**
- **نام‌گذاری:** برنامه‌های Wine باید به صورت `<نام-بسته>-wine` نام‌گذاری شوند.
- مثال: `notepad-wine`, `winrar-wine`.
- **وابستگی‌ها:**
- تمام بسته‌های Wine به `wine`, `winetricks`، و وابستگی‌های خاص خود نیاز دارند.
- **محل فایل‌ها:**
- باینری‌های قابل اجرا باید در `/opt/<نام-بسته>` قرار گیرند.
- در صورت نیاز به پیکربندی Wine، باید فایل‌های تنظیمات در `/etc/<نام-بسته>` ذخیره شوند.
#### **مثال PKGBUILD برای یک برنامه ساده در Wine:**
فرض کنیم می‌خواهید بسته **Notepad++** را در Wine بسته‌بندی کنید:
```bash
pkgname=notepadplusplus-wine
pkgver=8.5
pkgrel=1
arch=('x86_64')
pkgdesc="ویرایشگر متن Notepad++ برای اجرا تحت Wine"
license=('GPL')
depends=('wine' 'winetricks')
source=("https://github.com/notepad-plus-plus/notepad-plus-plus/releases/download/v${pkgver}/npp.${pkgver}.Installer.exe")
sha256sums=('d7e62d70d5d1dc0c4e31e9da57edb937d8a6e3c5457e405fc41d1e1dbb2b34cf')
package() {
install -Dm755 "$srcdir/npp.${pkgver}.Installer.exe" "$pkgdir/usr/share/notepadplusplus/installer.exe"
echo '#!/bin/bash' > "$pkgdir/usr/bin/notepadplusplus"
echo 'wine /usr/share/notepadplusplus/installer.exe' >> "$pkgdir/usr/bin/notepadplusplus"
chmod +x "$pkgdir/usr/bin/notepadplusplus"
}
```
---
### **6. بسته‌بندی برنامه‌های اندروید برای Waydroid**
#### **قواعد خاص برای Waydroid:**
- **نام‌گذاری:** بسته‌های اندرویدی باید به صورت `<نام-برنامه>-waydroid` نام‌گذاری شوند.
- مثال: `whatsapp-waydroid`, `vlc-waydroid`.
- **فرمت APK:** فایل‌های APK به عنوان منبع بسته‌بندی استفاده می‌شوند.
- **وابستگی‌ها:** تمامی بسته‌ها به `waydroid` نیاز دارند.
#### **مثال PKGBUILD برای برنامه اندروید:**
فرض کنیم می‌خواهید برنامه WhatsApp را بسته‌بندی کنید:
```bash
pkgname=whatsapp-waydroid
pkgver=2.23.12.76
pkgrel=1
arch=('any')
pkgdesc="WhatsApp Messenger برای اجرا تحت Waydroid"
license=('custom')
depends=('waydroid')
source=("https://www.whatsapp.com/android/current/WhatsApp-${pkgver}.apk")
sha256sums=('4a5d8a6f2c54b6f6fa7e652ff8a5eb37c68a1299f65863b0af8b5d3ef4e3c91b')
package() {
install -Dm644 "$srcdir/WhatsApp-${pkgver}.apk" "$pkgdir/usr/share/waydroid/apps/WhatsApp-${pkgver}.apk"
}
```
#### **نصب و اجرای APK در Waydroid:**
برای نصب خودکار برنامه، می‌توانید اسکریپتی اضافه کنید:
```bash
post_install() {
waydroid app install /usr/share/waydroid/apps/WhatsApp-${pkgver}.apk
}
```
---
### **7. مدیریت وابستگی‌ها**
- **وابستگی‌های اجرا (depends):** بسته‌هایی که نرم‌افزار به آن‌ها نیاز دارد (مثل `wine`, `fontconfig`, `waydroid`).
- **وابستگی‌های ساخت (makedepends):** ابزارهایی که فقط برای ساخت بسته موردنیاز هستند (مثل `gcc`, `cmake`).
---
### **8. تست بسته‌ها**
1. **تست با `namcap`:**
```bash
namcap PKGBUILD
namcap <نام-بسته>.pkg.tar.zst
```
2. **تست اجرا روی Waydroid یا Wine:**
- Waydroid:
```bash
waydroid app install <نام-فایل-APK>
waydroid app launch <نام-برنامه>
```
- Wine:
```bash
wine /opt/<نام-برنامه>/<فایل-اجرایی>
```
---
### **9. ارسال بسته‌ها به مخازن**
- در گیت‌لب پارچ حساب بسازید
- بسته‌خود را با توجه به بسته‌بندی های موجود در مخزن pkgbuilds پارچ به صورت یک درخواست ادغام ارائه دهید.
- تا تأیید و تست‌های تیم پارچ صبر کنید.
- پس از تأیید توسط تیم پارچ بسته شما با توجه به نوع در یکی از مخازن ppr و pcp بارگذاری می‌شود

63
fa/parch-riscv.md Normal file
View file

@ -0,0 +1,63 @@
---
title: پارچ ریسک پنج
description: ریسک پنج یک معماری جایگزین و آزاد برای معماری‌های اینتلی و آرم می‌باشد.
published: true
date: 2025-02-08T16:03:48.007Z
tags:
editor: markdown
dateCreated: 2025-02-08T16:02:39.332Z
---
# پارچ ریسک پنج
## ریسک پنج چیست؟
RISC-V (تلفظ: ریسک-فایو) یک معماری مجموعه دستورالعمل (ISA) بازمتن (Open-Source) و مبتنی بر فلسفه پردازش کاهش‌یافته دستورالعمل (RISC) است. این معماری به عنوان یک استاندارد آزاد و بدون محدودیت‌های حق امتیاز طراحی شده و انقلابی در دنیای سختافزارهای کامپیوتری محسوب می‌شود.
## پارچ بر روی ریسک پنج
این فقط برای تست Parch Gnu/Linux بر روی RISC-V است.
### پیش‌نیازها
- `arch-install-scripts`
- `parted`
- `git`
- `qemu-img`
- `qemu-system-riscv`
- `riscv64-linux-gnu-gcc`
- `devtools-riscv64`
همه پیش‌نیازها در مخزن موجود هستند و می‌توانید با استفاده از دستور زیر آن‌ها را نصب کنید:
```bash
sudo pacman -S arch-install-scripts parted git qemu-img devtools-riscv64 qemu-system-riscv riscv64-linux-gnu-gcc
```
### مراحل ساخت
مخزن پارچ ریسک پنج را کلون کنید:
```bash
git clone --depth 1 https://git.parchlinux.com/ports/parch-riscv.git
```
سپس برای ساخت RootFS و تصویر Qcow، از دستورات زیر استفاده کنید:
```bash
./mkrootfs
./mkimg
```
### شروع QEMU
>شما ابتدا باید از initrd fallback استفاده کنید و سپس با استفاده از دستور `mkinitcpio -P` initramfs را دوباره تولید کنید تا بتوانید از نسخه غیر fallback استفاده کنید.
{.is-warning}
برای شروع QEMU، از دستور زیر استفاده کنید:
```bash
./startqemu.sh [qcow Image]
```
برای تست این سیستم، به Parch Linux نیاز دارید.

56
fa/phone-webcam.md Normal file
View file

@ -0,0 +1,56 @@
---
title: استفاده از دستگاه اندرویدی به عنوان وب‌کم
description:
published: true
date: 2024-07-29T18:44:58.943Z
tags: پارچ, وب‌کم, اندروید
editor: markdown
dateCreated: 2024-07-29T18:44:09.325Z
---
# چگونه از تلفن اندرویدی به عنوان وب‌کم در پارچ استفاده کنیم؟
## نصب پیش‌نیاز ها
اول از همه باید چند پیش‌نیاز را نصب کنید:
```bash
sudo pacman -S scrcpy dkms base-devel linux-headers v4l2loopback-dkms
```
سپس باید ماژول را بارگذاری کنید:
```bash
sudo modprobe v4l2loopback exclusive_caps=1
```
## استفاده
### به اشتراک گذاری دوربین
برای استفاده از دوربین جلو ابتدا **usb debugging** را در گوشی خود فعال کنید، سپس گوشی خود را از طریق کابل به رایانه وصل کنید و این دستور را در ترمینال اجرا کنید:
```bash
scrcpy --video-source=camera --camera-size=1920x1080 --camera-facing=front --v4l2-sink=/dev/video0 --no-playback --no-window
```
برای دوربین پشتی، کافی است ```--camera-facing=front``` را به ```--camera-facing=back``` تغییر دهید.
#### تست دوربین
obs را باز کنید یا این دستور را اجرا کنید:
```bash
ffplay /dev/video0
```
### به اشتراک گذاری میکروفون
برای میکروفون می توانید این دستور را اجرا کنید:
```bash
scrcpy --no-video --audio-source=mic --no-window
```
این دستور میکروفون تلفن شما را به عنوان صدای سیستم به اشتراک می گذارد.

54
fa/plasma.md Normal file
View file

@ -0,0 +1,54 @@
---
title: کی‌دی‌ای پلاسما
description:
published: true
date: 2024-11-20T15:19:49.493Z
tags: پارچ, پلاسما, کی‌دی‌ای
editor: markdown
dateCreated: 2024-11-19T17:32:05.385Z
---
# کی‌دی‌ای پلاسما
## کی‌دی‌ای پلاسما چیست؟
کی‌دی‌ای پلاسما یک محیط میزکار یا ویژگی‌های زیاد و قابلیت شخصی‌سازی بالا است که تجربه کاربری مدرن و شهودی‌ای ارائه می‌دهد. همچنین برای انعطاف‌پذیری، گزینه‌های شخصی‌سازی زیاد و طیف گسترده‌ای از برنامه‌ها و ابزارها نیز شناخته شده است.
پارچ لینوکس پلاسما نسخه **پرچمدار** توزیع پارچ لینوکس است.
![screenshot](https://raw.githubusercontent.com/parchlinux/parch-iso-plasma/main/image/screenshot.png)
## نصب کردن
شما می‌توانید با نصب پارچ لینوکس پلاسما یا با تغییر میزکار خود پلاسما را نصب کنید.
برای تغییر میزکار شما نیازمند نصب این بسته‌ها هستید:
```bash
sudo pacman -S plasma konsole kate dolphin sddm ark # for minimal installation
sudo pacman -S plasma konsole kate dolphin sddm ark plasmatube tokodon merkuro neochat marknote # for full ParchLinux plasma packages
```
>
> اگر از آخرین نسخه گنوم مهاجرت می‌کنید؛ یادتان باشد `QT_QPA_PLATFORMTHEME=qt6ct` را از فایل `/etc/envierment` حذف کنید.
{.is-info}
## نکات و ترفندها
### گرفتن اسکرین شات از قسمتی
با فشار دادن <kbd>meta</kbd> + <kbd>shift</kbd> + <kbd>print</kbd> برنامه spectacle به شما اجازه می دهد قسمتی از صفحه برای اسکرین شات گرفتن انتخاب کنید.
### عوض کردن لوگوی منو به لوگوی پارچ لینوکس
تاکنون، ما لوگوی پارچ را بر روی منوی برنامه‌ها اعمال نکردیم. برای تغییر آن روی منو کلیک راست کنید و روی گزینه `Configure application menu` کلیک کنید سپس فایل `parch-logo.svg` را از این مکان انتخاب کنید:
`/usr/share/pixmaps/parch-logo.svg`
### انتخاب‌گر فایل کی‌دی‌ای برای فایرفاکس
برای اینکه فایرفاکس با کی‌دی‌ای بهتر کار کند, می‌توانید یا بسته `firefox-kde-opensuse`^AUR^ را نصب کنید، یا به طور دستی تنظیم کنید:
برای استفاده از انتخابگر فایل kde در فایرفاکس ۶۴ یا جدیدتر، بسته‌های `xdg-desktop-portal` و `xdg-desktop-portal-kde`, را نصب کنید؛ سپس فایرفاکس را باز کنید و در صفحه `about:config` مقدار `widget.use-xdg-desktop-portal.file-picker` را به ۱ تغییر دهید.

View file

@ -0,0 +1,232 @@
---
title: استفاده از انویدیا در پارچ
description:
published: true
date: 2024-11-19T17:21:58.813Z
tags: پارچ, انویدیا
editor: markdown
dateCreated: 2024-11-13T18:31:50.299Z
---
## استفاده از گرافیک انویدیا در پارچ
با گفته‌های بزرگان و کاربران گنو/لینوکس، کارت گرافیک انویدیا در لینوکس دردسرهای فراوانی دارد و شبیه یک غول ترسناک به نظر می‌رسد اما امروز اینجاییم که این غول بزرگ را محو کنیم!
## نصب درایور
### درایور انحصاری انویدیا
پیش از هرکاری، ابتدا باید تشخیص بدهیم که چه نسخه از درایور با گرافیک ما سازگار است بنابراین باید برنامه nvidia-helper را از مخازن پارچ نصب کنیم و آن‌را اجرا کنیم:
```bash
sudo pacman -S nvidia-helper && nvidia-helper
```
اگر این خروجی را گرفتیم یعنی میتوانیم آخرین نسخه درایور را نصب بنمایم:
```
Your card is supported by the latest drivers.
It is recommended to install the nvidia package or install the nvidia-dkms package for custom kernels
```
مراحل نصب:
۱. ابتدای امر به کمک ویرایشگر نانو فایل `/etc/mkinitcpio.conf` را باز کنید:
```bash
sudo nano /etc/mkinitcpio.conf
```
۲. به‌این صورت بخش MODULES را پر کنید:
```
MODULES=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)
```
۳. بعد از این کار از بخش `HOOKS` در همان فایل، کلمه kms را حذف کنید؛ به کمک میانبر <kbd>Ctrl + o</kbd> و سپس زدن اینتر فایل را ذخیره نموده و با میانبر <kbd>Ctrl + x</kbd> از ویرایشگر خارچ شوید.
۴. در آخر به کمک دستور زیر درایور و اجزای آن را نصب نمایید:
```bash
sudo pacman -S nvidia nvidia-utils nvidia-settings nvidia-pacman-hook
```
> **نکته**
اگر شما کرنل کاستوم نصب نموده اید باید درایور nvidia-dkms را نصب کنید:
sudo pacman -S nvidia-dkms nvidia-utils nvidia-settings
اگر کرنل lts دارید:
sudo pacman -S nvidia-lts nvidia-utils nvidia-settings
{.is-info}
اما اگر یکی از خروجی های زیر را گرفتید با توجه به نام درایوری که برایتان نوشته شده یکی از درایورها را نصب کنید:
```
Your card is supported by the Tesla(470xx) dkms drivers.
Your card is supported by the legacy 390xx drivers.
Your card is supported by the legacy 340xx drivers.
```
به کمک دستورات:
```bash
paru -S nvidia-470xx-dkms nvidia-470xx-settings or paru -S nvidia-390xx-dkms nvidia-390xx-settings or paru -S nvidia-340xx-dkms nvidia-340xx-settings
```
### نصب درایور آزاد
در گنو/لینوکس، دو درایور آزاد برای گرافیک‌های انویدیا داریم:
۱.nouveau
این درایور به‌صورت پیشفرض در کرنل موجود است و نیازمند نصب چیز دیگری نیست. اما مشکلات بسیار زیادی از جمله عدم کنترل سرعت فن و عملکرد ضعیف دارد؛ بنابراین توصیه نمی‌شود.
۲.nvidia-open
از نسخه 510 به بعد، درایور nvidia-open منتشر شد که کد کرنل آن باز است و از گرافیک های سری تورینگ به بالا ساپورت میکند، اینجا لیست گرافیک‌هایی است که از این درایور پشتیبانی می‌کنند.
نحوه نصب آن به این شکل است، ابتدا باید به کمک ویرایشگر نانو فایل `/etc/mkinitcpio.conf` را باز کنیم:
```bash
sudo nano /etc/mkinitcpio.conf
```
سپس بخش MODULES را اینگونه پر کنید:
```
MODULES=(nvidia-open)
```
بعد از این کار از بخش `HOOKS` همان فایل، کلمه kms را حذف کنید؛ به کمک میانبر <kbd>Ctrl + o</kbd> و سپس زدن اینتر فایل را ذخیره نموده و با میانبر <kbd>Ctrl + x</kbd> از ویرایشگر خارچ شوید.
در آخر درایور و مشتقات آن را نصب نمایید:
```bash
sudo pacman -S nvidia-open nvidia-utils nvidia-settings
```
>**نکته**
اگر کرنل کاستوم یا کرنل lts نصب نموده‌اید باید درایور nvidia-open-dkms را نصب نمایید:
sudo pacman -S nvidia-open-dkms nvidia-utils nvidia-settings
{.is-info}
## نکات مهم
۱. برای اجرای بازی ها به کمک گرافیک انویدیا باید درایور ۳۲ بیتی انویدیا و mesa و ولکان هر دو نسخه ۶۴ و ۳۲ بیتی را نصب کنید.
اگر درایور انحصاری انویدیا یا nvidia-open را دارید:
```bash
sudo pacman -S vulkan-icd-loader lib32-vulkan-icd-loader lib32-nvidia-utils mesa lib32-mesa
```
اگر درایور nouveau دارید:
```bash
sudo pacman -S vulkan-icd-loader lib32-vulkan-icd-loader vulkan-nouveau lib32-vulkan-nouveau
```
۲. اجرای بهتر ویلند و کامپازیتورهای آن
از نسخه ۳۶۴ درایور به بعد فلگ `nvidia_drm.modeset=1` جهت عملکرد بهتر ویلند و X11 در حالت روت اضافه شده است، از آنجایی که درایور انویدیا نمی‌تواند به صورت با تنظیم‌گر حالت کرنل لینوکس(Kernel Mode Setting یا به اختصار KMS) سازگار باشد و اگر تنظیم‌گر دیر بارگذاری شود یا بعد از اجرای پروتکل نمایش بالا بیاید، دیگر به صورت خودکار نمی‌تواند وضوح و عمق نمایشگر را تنظیم کند و امکان تعویض کنسول(tty) دیگر فراهم نیست؛ پس این فلگ به درایور افزوده شد که تنظیم‌گر مدیر هسته DRM انویدیا را با kms جایگزین می‌کند؛ جهت گذاشتن این فلگ در پارامتر های کرنل این دستور را وارد کنید:
```bash
sudo tee /etc/modprobe.d/nvidia-modeset.conf <<< 'options nvidia_drm modeset=1'
```
همچنین از نسخه ۵۴۵ به بعد درایور، فلگ nvidia_drm.fbdev=1 را نیز افزوده شد که simpledrm را مدیر هسته DRM می‌کند که برای کنسول(tty) با نمایشگر دارای رزولوشن بالا است. برای فعالسازی و افزودن آن به متغیرهای کرنل دستور زیر را وارد کنید:
```bash
sudo tee /etc/modprobe.d/nvidia-modeset.conf <<< 'options nvidia_drm modeset=1 fbdev=1'
```
## سوییچ بین دو کارت گرافیک در لپ‌تاپ
برای اینکار دو برنامه آسان و راحت وجود دارد:
### Bumblebee (توصیه نمی‌شود)
این برنامه به کمک فناوری NVIDIA Optimus موجود در گرافیک های انویدیا، بین دو گرافیک موجود با توجه به سنگینی کار درحال انجام، سوییچ می‌کند.
بامبل بی به این‌صورت کار می‌کند که هسته DRM انویدیا یا `nvidia-drm` را درهنگام بوت مسدود میکند و نمی‌گذارد درایور در هنگام بوت بارگذاری و نمایشگر روی گرافیک انویدیا تنظیم شود، بلکه نمایشگر از کارت گرافیک مجتمع قدرت می‌گیرد و زمانی که درحال انجام کار سبکی مانند وب گردی هستید یا روی حالت استندبای قرار دارید؛ قدرت را از کارت گرافیک مجتمع می‌گیرد و به نمایشگر منتقل می‌کند.
>**نکته**
به دلیل این نحوه کارکرد بامبل بی ممکن است دچار مشکلاتی از جمله کمبود fps در بازی‌ها یا افت عملکرد در سایر برنامه‌ها شوید، [اینجا](https://bbs.archlinux.org/viewtopic.php?pid=1822926) یا [اینجا](https://github.com/Witko/nvidia-xrun/issues/4#issuecomment-153386837) را ببینید. همچنین مقایسه عملکرد بامبل بی با تک-سوییچر nvidia-xrun را هم در [اینجا](https://wiki.archlinux.org/title/Bumblebee#Optimizing_speed) می‌توانید ببینید.
همچنین موقع سوییچ بین دو گرافیک بنا به خاطر فرایند روشن کردن گرافیک مجزا و انتقال قدرت به آن احتمال پارگی یا سیاه شدن صفحه نمایش وجود دارد.
{.is-info}
اگر درحال انجام کار سنگین باشید مانند ویرایش ویدیو با بازی کردن، بامبل بی تنظیم می‌کند که برنامه موردنظر از کارت گرافیک انویدیا استفاده کند اما نمایشگر از کارت گرافیک انویدیا استفاده نکند و صرفا قدرت گرافیک انویدیا به نمایشگری که از گرافیک مجتمع استفاده می‌کند، منتقل شود.
>**هشدار**
بامبل بی درایور هسته DRM انویدیا را مسدود می‌کند تا درایور انویدیا در هنگام بوت بارگذاری نشود، اگر سراغ راه دیگری می‌روید، بامبل بی را حذف کنید تا گرافیک انویدیا بتواند فعال شود.
{.is-warning}
برای نصب آن به این شکل عمل کنید، با فرض اینکه شما درحال استفاده از درایور nvidia هستید:
```bash
sudo pacman -S bumblebee mesa lib32-nvidia-utils lib32-virtualgl
```
سپس کاربر خود را به گروه بامبل بی اضافه نموده و سپس سرویس بامبل بی را روشن کنید (منظور از $user نام یوزر شماست):
```bash
sudo gpasswd -a $user bumblebee && sudo systemctl enable --now bumblebeed.service
```
در نهایت سیستم خود را ریستارت کنید.
#### مدیریت انرژی در بامبل بی
بامبل بی به صورت خودکار کارت گرافیک مجزا را درهنگام بیکاری، خاموش نمی‌کند بنابراین ما نیازمند برنامه دیگری هستیم که این کار را انجام دهد، برنامه bbswatch این‌کار را برای ما انجام می‌دهد کافی است که آن را نصب کنیم:
```bash
sudo pacman -S bbswitch
```
برای کرنل lts یا کرنل های کاستوم:
```bash
sudo pacman -S bbswitch-dkms
```
>**نکته**
این برنامه نیازمند بامبل بی نیست و در هرصورتی می‌توانید آن را نصب کنید اما برای کامپیوتر های غیرقابل حمل این روش کار نمی‌کند.
{.is-info}
### Envycontrol
این برنامه همانند بامبل بی به کمک تکنولوژی NVIDIA Optimus کار می‌کند، اما برخلاف بامبل بی ۳ حالت مختلف دارد و کاربر باید آن‌را به صورت دستی تنظیم کند.
برخلاف بامبل بی این سوییچر مشکلات افت فریم یا پارگی صفحه نمایش موقع سوییچ کردن را ندارد و حتی مکانیزم هایی برای حل پارگی صفحه نمایش(اگر آن را دارید.) دارد.
دستور نصب آن به این شکل است:
```bash
sudo pacman -S envycontrol
```
#### تنظیم حالت سوییچر envycontrol
اگر میخواهید سیستم به صورت خودکار بین دو گرافیک سوییچ کند این دستور را وارد کنید:
```bash
sudo envycontrol -s hybrid
```
>**نکته**
envycontrol برای کنترل مصرف انرژی در پردازنده های گرافیکی سری تورینگ به بالا انویدیا، فلگ `--rtd3` را دارد که مقدار پیشفرض آن ۲ است، ۱ کمترین درجه و ۳ بیشترین درجه آن است. این فلگ مانند bbswatch عمل می‌کند و زمانی که کارت گرافیک انویدیا در حالت بیکاری است مقدار مصرف انرژی آن را کم می‌کند و بیشترین درجه تقریبا کارت گرافیک را به حالت خاموشی می‌برد، این فلگ تنها درحالت هایبرید کار می‌کند.
برای تنظیم آن به عنوان مثال به این شکل عمل کنید:
sudo envycontrol -s hybrid --rtd3 2
اگر نیازمند این ویژگی هستید اما پردازنده گرافیکتان سری پاسکال به پایین است به این [بخش](#مدیریت_انرژی_در_بامبل_بی) مراجعه کنید.
{.is-info}
اگر میخواهید فقط از گرافیک اینتل یا انویدیا استفاده بنمایید به این شکل عمل کنید:
```bash
:For Only nvidia
sudo envycontrol -s nvidia --dm DM
:For only intel/amd
sudo envycontrol -s integrated --dm DM
```
(منظور از `DM` دیسپلی منیجر توزیعتان است مانند sddm یا gdm، در اینجا مدیر نمایش را معرفی میکنیم تا در فایل‌های مدیر نمایش تنظیم شود که با گرافیک انویدیا یا گرافیک مجتمع بالا بیایند و میزکار را با چه کارت گرافیکی بارگذاری کند.)

57
fa/waydroid.md Normal file
View file

@ -0,0 +1,57 @@
---
title: وی‌دروید
description: Waydroid در پارچ لینوکس
published: true
date: 2024-07-26T07:45:47.872Z
tags:
editor: markdown
dateCreated: 2024-07-25T05:32:13.346Z
---
# وی‌دروید
وی‌دروید یک رویکرد مبتنی بر کانتینر برای راه‌اندازی یک سیستم اندروید کامل در یک سیستم گنو/لینوکس است.
## نصب وی‌دروید
در پارچ لینوکس اسکریپتی به نام `waydroid-helper` وجود دارد که می تواند برای نصب وی‌دروید با یک ایمیج غیر gapps (ایمیج اندروید بدون برنامه های گوگل مانند play store) در Parch Linux استفاده شود.
برای شروع باید اسکریپت را از مخزن بسته‌های پارچ نصب کنید:
```bash
sudo pacman -S waydroid-helper
```
### بررسی سیستم مورد نیاز
برای بررسی اینکه آیا سیستم شما با وی‌دروید سازگار است یا خیر، باید اسکریپت waydroid-checker را اجرا کنید.
```bash
waydroid-checker
```
پس از اجرای آن با این صفحه مواجه می شوید:
![](https://wiki.parchlinux.com/waydroid-checker1.png)
اکنون بر روی Start Test کلیک کنید.
![](https://wiki.parchlinux.com/waydroid-checker2.png)
پس از اتمام تست، اگر CPU شما موفق شد، می توانید به نصب ادامه دهید
### نصب وی‌دروید
برای شروع نصب می توانید اسکریپت `waydroid-installer` را اجرا کنید:
```bash
waydroid-installer
```
### مراحل بعد از نصب
پس از اتمام نصب، باید وی‌دروید را راه اندازی کنید:
```bash
sudo waydroid init
```
پس از اتمام آن، اگر در wayland هستید، می توانید وی‌دروید را از منوی برنامه خود اجرا کنید.
## X11
برای اجرای وی‌دروید تحت X11، باید `waydroid-x11` را از ترمینال اجرا کنید:
```bash
waydroid-x11
```
این برنامه وی‌دروید را در محیط‌های x11 مانند XFCE، Mate و غیره تحت weston راه اندازی می کند.

90
fa/wine.md Normal file
View file

@ -0,0 +1,90 @@
---
title: واین
description: لایه سازگاری برنامه‌های ویندوزی با گنو/لینوکس
published: true
date: 2024-11-10T16:18:25.088Z
tags: لینوکس, واین
editor: markdown
dateCreated: 2024-11-10T16:18:20.333Z
---
# واین
واین (WINE) که مخفف بازگشتی wine is not an emulator هستش یک لایه سازگاری برای اجرای برنامه‌های ویندوزی بر روی گنو/لینوکس می‌باشد.
## نصب بر روی پارچ
برای نصب واین بر روی پارچ کافی هستش تا ترمینال رو باز کنید و این دستور رو داخلش بزنید:
```bash
sudo pacman -S wine wine-mono wine-gecko
```
## استفاده از واین
برای استفاده از واین کافیه تا اول دستور ```winecfg``` رو داخل ترمینال اجرا کنید و بعد از انجام دادن تنظیمات اولیه با دستور
```
wine program.exe
```
برنامه مورد نظرتون رو اجرا کنید.
>**هشدار**
لایه سازگاری واین با اکثر برنامه‌ها ممکنه به خوبی کار نکنه پس قبل از نصب یک برنامه از سازگاری اون با واین اطمینان حاصل کنید.
{.is-warning}
## برنامه‌های گرافیکی برای مدیریت واین
>**نکته**
بعضی از برنامه‌ها از AUR نصب می‌شوند، اطمینان حاصل کنید که ابتدا آموزش استفاده از [مدیربسته](https://wiki.parchlinux.com/fa/Package-management) را مطالعه کرده باشید.
{.is-info}
>**هشدار**
این ابزارها دارای جوامع و وب‌سایت‌های اختصاصی خود هستند و توسط جامعه اصلی Wine پشتیبانی نمی‌شوند.
{.is-warning}
### Bottles
مدیر گرافیکی برای مدیریت پریفیکس‌ها و رانرهای Wine که بر پایه GTK ساخته شده است.
- [وب‌سایت Bottles](https://usebottles.com)
- بسته AUR: [bottles](https://aur.archlinux.org/packages/bottles)
### CrossOver
نسخه رسمی پولی Wine که یک رابط گرافیکی و پشتیبانی کامل‌تری برای کاربران فراهم می‌کند.
- [وب‌سایت CrossOver](https://www.codeweavers.com/crossover)
- بسته AUR: [crossover](https://aur.archlinux.org/packages/crossover)
### Lutris
لانچر بازی برای انواع بازی‌ها، از جمله بازی‌های Wine (با مدیریت پریفیکس)، بازی‌های بومی لینوکس و شبیه‌سازها.
- [وب‌سایت Lutris](https://lutris.net)
- بسته AUR: [lutris](https://aur.archlinux.org/packages/lutris)
### PlayOnLinux
مدیر گرافیکی پریفیکس برای Wine. دارای اسکریپت‌هایی برای نصب و پیکربندی برنامه‌ها.
- [وب‌سایت PlayOnLinux](https://www.playonlinux.com)
- بسته AUR: [playonlinux](https://aur.archlinux.org/packages/playonlinux)
### Proton
ابزاری برای سازگاری که برای Steam طراحی شده و بر پایه Wine و اجزای اضافی است. برای مشاهده لیست سازگاری به ProtonDB مراجعه کنید.
- [مخزن GitHub Proton](https://github.com/ValveSoftware/Proton)
- بسته AUR: [proton](https://aur.archlinux.org/packages/proton)
### PyWinery
یک مدیر ساده گرافیکی برای پریفیکس‌های Wine.
- [مخزن GitHub PyWinery](https://github.com/ergoithz/pywinery)
- بسته AUR: [pywinery](https://aur.archlinux.org/packages/pywinery)
### Q4Wine
مدیر گرافیکی پریفیکس برای Wine. می‌تواند تم‌های Qt را در تنظیمات Wine برای ادغام بهتر اعمال کند.
- [وب‌سایت Q4Wine](https://sourceforge.net/projects/q4wine/)
- بسته AUR: [q4wine-git](https://aur.archlinux.org/packages/q4wine-git)
### WINEgui
رابط گرافیکی کاربرپسند برای WINE.
- [مخزن GitLab WINEgui](https://gitlab.melroy.org/melroy/winegui)
- بسته‌های AUR: [winegui](https://aur.archlinux.org/packages/winegui)، [winegui-bin](https://aur.archlinux.org/packages/winegui-bin)

45
fa/xampp.md Normal file
View file

@ -0,0 +1,45 @@
---
title: XAMPP
description:
published: true
date: 2024-11-20T15:12:16.989Z
tags: xampp, php, آپاچی, پهپ
editor: markdown
dateCreated: 2024-11-20T13:44:50.986Z
---
# XAMPP
> XAMPP یک توزیع آپاچی با نصب آسان است که حاوی برنامه‌های MariaDB، PHP، Perl و ProFTPD می‌باشد، همچنین شامل برنامه های:
Apache, MariaDB, PHP & PEAR, Perl, ProFTPD, phpMyAdmin, OpenSSL, GD, Freetype2, libjpeg, libpng, gdbm, zlib, expat, Sablotron, libxml, Ming, Webalizer, pdf class, ncurses, mod_perl, FreeTDS, gettext, mcrypt, mhash, eAccelerator, SQLite و IMAP C-Client نیز می‌شود.
## نصب کردن
شما می‌توانید XAMPP را از AUR به کمک paru در پارچ لینوکس نصب کنید:
```bash
paru -S xampp
```
## کانفیگ کردن
کانفیگ پیش‌فرض باید خارج از جعبه کار کند. با ویرایش فایل های زیر می توانیم بخش های مختلف XAMPP را تنظیم کنیم:
- ```/opt/lampp/etc/httpd.conf``` — کانفیگ آپاچی. برای مثال شما میتوانید پوشه حاوی فایل‌های متعلق به وب‌پیچ را عوض کنید.
- ```/opt/lampp/etc/php.ini``` — کانفیگ PHP.
- ```/opt/lampp/phpmyadmin/config.inc.php``` — کانفیگ phpMyAdmin.
- ```/opt/lampp/etc/proftpd.conf``` — کانفیگ ProFTPD.
- ```/opt/lampp/etc/my.cnf``` — کانفیگ MySQL.
اگر فقط می‌خواهید امنیت سرور را تنظیم کنید؛ این را اجرا کنید:
```bash
/opt/lampp/xampp security
```
## استفاده
برای کنترل XAMPP دستور آورده شده در زیر را وارد کنید:
```bash
/opt/lampp/xampp start,stop,restart
```
**به عنوان جایگزین**, شما می‌توانید سرویس ```xampp.service``` را شروع یا متوقف یا مجددا راه اندازی کنید.

21
fa/ات.md Normal file
View file

@ -0,0 +1,21 @@
---
title: ات
description: at فرمان‌ها را از ورودی استاندارد یا یک پروندهٔ مشخص شده برای اجرا در زمانی دیگر می‌خوانند.
published: false
date: 2024-11-20T13:23:33.146Z
tags: مدیریت سامانه, خط فرمان
editor: markdown
dateCreated: 2024-11-17T16:36:04.386Z
---
[**at**](https://salsa.debian.org/debian/at) و **batch** دستورات را از ورودی استاندارد یا یک فایل مشخص می‌خوانند تا در زمانی دیگر با استفاده از /bin/sh اجرا شوند.
## *۱*. نصب
بستهٔ `at` را نصب کنید:
```bash
sudo pacman -S at
```
## *۲*. استفاده

44
fa/خواندن.md Normal file
View file

@ -0,0 +1,44 @@
---
title: کمک:خواندن
description:
published: true
date: 2024-11-29T11:49:54.265Z
tags: ویکی پارچ, دربارهٔ پارچ, کمک
editor: markdown
dateCreated: 2024-11-17T17:10:27.699Z
---
از آنجا که بخش عمده‌ای از ویکی پارچ حاوی نکاتی است که ممکن است برای کاربران تازه‌کار پارچ‌لینوکس (یا به طور کلی گنو/لینوکس) نیاز به توضیح داشته باشد، این خلاصه از رویه‌های پایه، هم برای جلوگیری از سردرگمی در درک مقالات و هم برای پرهیز از تکرار در محتوای آن‌ها نوشته شده است.
## *۱* سازماندهی
بیشتر مقالات در ویکی پارچ سعی نمی‌کنند دستورالعملی جامع درباره یک موضوع خاص ارائه دهند؛ در عوض، این مقالات با پیروی از اصل [«خودت را تکرار نکن»](https://wiki.c2.com/?DontRepeatYourself) نوشته شده‌اند، با این فرض که کاربر هر مطلب پیش‌نیازی را که هنوز درک نکرده است، جستجو کرده و خواهد خواند. در صورت امکان، چنین مطالب پیش‌نیازی با قالب‌بندی ویژه در مقاله مشخص شده‌اند، به بخش [#قالب‌بندی](https://wiki.parchlinux.com/fa/%D8%AE%D9%88%D8%A7%D9%86%D8%AF%D9%86#%DB%B2-%D9%82%D8%A7%D9%84%D8%A8%D8%A8%D9%86%D8%AF%DB%8C) مراجعه کنید.
به دلیل این نوع سازماندهی، ممکن است برای درک کامل یک مقاله در ویکی پارچ لازم باشد چندین منبع مرتبط را بررسی کنید. به‌ویژه، کاربرانی که در استفاده از پارچ (یا به طور کلی گنو/لینوکس) تازه‌کار هستند، باید انتظار داشته باشند که حتی برای حل مشکلات ساده هم مجبور به خواندن تعداد زیادی مقاله شوند. مطالعه مطالب پیش‌نیاز به‌ویژه پیش از درخواست کمک از سایر کاربران، اهمیت زیادی دارد.
## *۲* قالب‌بندی
* پیوند به یک بخش در مقاله فعلی: [**#سازماندهی**](https://wiki.parchlinux.com/fa/%D8%AE%D9%88%D8%A7%D9%86%D8%AF%D9%86#%DB%B1-%D8%B3%D8%A7%D8%B2%D9%85%D8%A7%D9%86%D8%AF%D9%87%DB%8C)
* پیوند به [**مقاله دیگری در پارچ‌ویکی**](https://wiki.parchlinux.com/fa/home)
* پیوند به یک [**صفحهٔ وب خارجی**](https://en.wikipedia.org/wiki/)
* پیوند به یک صفحهٔ راهنما: [`intro(1)` ](https://man.archlinux.org/man/intro.1)
* صفحه راهنمایی که فقط آفلاین دردسترس است: foo(1)
* پیوند به بسته‌ای در مخازن رسمی: [`foobar`](https://archlinux.org/packages/?name=foobar)
* پیوند به بسته‌ای در مخازن کاربر آرچ: [`foobar`](https://aur.archlinux.org/packages/foobar)^AUR^
## *۳* ریشه، کاربر عادی یا کاربر دیگر
برخی خطوط به این صورت نوشته می‌شوند:
```
mkinitcpio -p linux #
```
برخی دیگر پیشوند متفاوتی دارند:
```
makepkg -s $
```
علامت عددی یا هش (`#`) نشان می‌دهد که فرمان باید با دسترسی *ریشه* اجرا شود، درحالی که علامت دلار (`$`) نشان می‌دهد که فرمان باید توسط *کاربر عادی* اجرا شود.
> **توجه:** فرمان‌هایی که با `#` آغاز می‌شوند، قصد دارند از *پوسته ریشه* اجرا شوند، که به عنوان مثال به راحتی می‌توان با `sudo -i` به آن دسترسی پیدا کرد. اجرای `sudo` *`command`* از یک پوسته بدون امتیاز به جای *`command`* از یک پوسته ریشه در اکثر موارد کار خواهد کرد، با برخی استثنائات قابل توجه مانند [**هدایت مجدد**](https://en.wikipedia.org/wiki/Redirection_(computing)) و [**جایگزینی فرمان**](https://en.wikipedia.org/wiki/Command_substitution) که دقیقاً نیازمند یک پوسته ریشه هستند. مراجعه کنید به sudo#پوستهٔ ورود.
{.is-info}
هنگامی که فرمان‌ها نیاز به اجرا توسط کاربر خاصی دارند، با نام کاربری در داخل براکت پیشوند می‌شوند، برای مثال:

View file

@ -0,0 +1,451 @@
---
title: سوالات هوشمندانه
description: چگونه هوشمندانه سوال کنیم
published: true
date: 2025-02-19T05:55:18.440Z
tags: پرسیدن, پرسیدن-هوشمندانه, سوال-پرسیدن, سوال, سوال-هوشمندانه, هوشمندانه
editor: markdown
dateCreated: 2025-02-19T05:45:00.524Z
---
# چگونه هوشمندانه پرسش کنیم
## رفع ادعا
در قسمت چگونه کمک گرفتن در وب سایت تعدادی از پروژه‌ها، به این سند لینک داده‌اند.
این خوب است و همان استفاده‌ای است که ما قصدش را داشتیم — اما اگر شما مدیر سایتی هستید که در صفحهٔ پروژهٔ خود چنین لینکی قرار دادید، لطفاً نزدیک آن لینک این اعلان را که ما یک میز کمک برای پروژهٔ شما نیستیم بصورت برجسته نمایش دهید! ما به سختی آموخته‌ایم که بدون چنین اعلانی، افراد ساده و ابلهی پیدا می‌شوند که مکرراً ما را آزار می‌دهند. افرادی که فکر می‌کنند انتشار این سند، کار ما را به این تبدیل کرده که تمام مشکلات فنی جهان را حل کنیم.
اگر نیاز به کمک دارید و این سند را می‌خوانید و یا تصور می‌کنید که می‌توان مستقیماً از نویسندگان این سند کمک گرفت، شما هم یکی از همان افراد ابله در پرسیدن هستید. پرسش‌هایتان را از ما نپرسید. [وگرنه] ما فقط شما را نادیده خواهیم گرفت.
ما می‌خواهیم اینجا نشان دهیم چگونه از افرادی که واقعاً دانشی در مورد نرم‌افزار یا سخت‌افزار مورد نظرتان دارند، کمک بگیرید. البته در ۹۹٫۹ درصد مواقع، آن افراد ما '''نیستیم'''. بدون اطمینان به این‌که یکی از نویسندگان این سند در مورد مشکل شما تخصص دارد، ما را راحت بگذارید.
## مقدمه
در دنیای هکرها، نوع جوابی که برای پرسش‌های فنی خود می‌گیرید، هر چقدر که به سختی جواب دادنش بستگی دارد، همانقدر هم به روش پرسیدن شما بستگی دارد. این راهنما به شما یاد می‌دهد که چگونه بپرسید تا با احتمال بیشتری به پاسخ رضایت‌بخشی برسید.
حالا که کاربرد اوپن سورس رایج و گسترده شده است، معمولاً می‌توانید از کاربران با تجربه‌تر و هکرها جواب‌های خوبی دریافت کنید. این چیز خوبی است؛ کاربرانی که تمایل دارند که فقط کمی بیشتر در مورد مشکلات رایج تازه‌کارها بردباری کنند. با این حال اگر کاربران با تجربه مثل هکرها هم طبق روش‌هایی که ما اینجا پیشنهاد می‌کنیم رفتار کنند، عموماً موثرترین راه برای گرفتن پاسخ‌های مفید خواهد بود. نخستین چیزی که باید درک کنیم اینست که هکرها حقیقتاً مسائل سخت و سوالاتی را دوست دارند که به‌خوبی ذهن را درگیر می‌کند. اگر ما انجام ندادیم چون نمی‌خواستیم. اگر به ما پرسشی جالب توجه بدهید که به آن فکر کنیم، از شما سپاسگزار خواهیم بود؛ پرسش‌های خوب محرک ذهن بوده و یک هدیه هستند. این پرسش‌ها به ما کمک می‌کنند که فهم خود را توسعه دهیم، و معمولاً باعث آشکار شدن مشکلاتی می‌شود که ممکن است ندانیم یا به آن‌ها توجهی نکرده باشیم. در میان هکرها، «پرسش خوب!» یک درود بزرگ و مخلصانه است.
با این وجود، هکرها مشهورند که در مقابل پرسش‌های ساده به‌نظر با دشمنی و تکبر برخورد می‌کنند. این گاهی به نظر می‌رسد که ما واکنش گستاخانه‌ای با تازه‌کارها و افراد ناآگاه داریم. اما واقعاً اینطور نیست. چیزی که ما بدون شرمندگی باید بگوییم، خصومت با افرادی است که ظاهراً تمایلی به فکر کردن ندارند یا نمی‌خواهند وظیفه خود را قبل از پرسیدن انجام دهند. این افراد کُشندهٔ وقت هستند — می‌گیرند و پس نمی‌دهند، و آنها وقت ما را هدر می‌دهند، وقتی که می‌توانیم صَرف پاسخ دادن به پرسش‌های بهتر کنیم، صَرف افرادی کنیم که بیشتر شایستهٔ پاسخ دادن هستند. ما چنین افرادی[که وقت را هدر می‌دهند] را «loserها» می‌خوانیم (و به دلایل تاریخی، گاهی آن را «luserها» تلفظ می‌کنیم).
ما درک می‌کنیم که افرادی هستند که تنها می‌خواهند از نرم‌افزارهایی که ما نوشته‌ایم استفاده کنند، و علاقه‌ای به آموختن جرئیات فنی ندارند. برای بیش‌تر مردم کامپیوتر فقط یک ابزار و واسطه‌ای برای رسیدن به یک هدف است؛ آنها کارهای مهمتری برای انجام دادن دارند، کارهایی که زندگی به آن‌ها وابسته است. ما این را تصدیق می‌کنیم، و انتظار نداریم که همه به مسائل فنی مورد علاقهٔ ما علاقه داشته باشند. با این حال، سبک جواب دادن ما به سوالات، برای مردمی که چنین علاقه‌ای دارند تنظیم شده است، افرادی که می‌خواهند در حل مشکل، سهم فعالی داشته باشند. این سبک تغییر نخواهد کرد. کسی از ما قصد تغییر دادنش را ندارد؛ اگر این سبک را تغییر دهیم، در چیزهایی که بهتر از همه می‌توانیم انجام دهیم، کمتر مؤثر خواهیم بود.
ما به شدت داوطلب هستیم. ما در زمان‌هایی که سرمان شلوغ نیست، روی جواب دادن به سوالات وقت می‌گذاریم، و در آن مواقع ما غرق در این سوالات هستیم. پس ما بدون ترس، پرسش‌ها را فیلتر می‌کنیم. به ویژه، ما پرسش‌های افراد بازنده (loser) را به دور می‌اندازیم تا زمان خود برای جواب دادن به سوالات را بهتر صرف کنیم، برای پاسخ دادن به افراد برنده (winner).
اگر شما این رفتار ما را گزنده، فروتنی یا خودبینی می‌یابید، پنداشت‌های خود را بررسی کنید. ما نمی‌خواهیم که در مقابلمان زانو بزنید — در واقع اکثرِ ما هیچ چیز را بیشتر از این دوست ندارند که با شما بصورت برابر معامله کنند، و ورود شما به جامعهٔ خود را خوش‌آمد بگویند، اگر تلاش کافی برای میسر شدن آن را داشته باشید. اما برای ما به سادگی کارآمد نیست که سعی کنیم به افرادی کمک کنیم که نمی‌خواهند به خودشان کمک کنند. انسان ممکن است جاهل باشد؛ اما نباید احمقانه رفتار کند.
پس، درحالی‌که لازم است که شایستگی فنی برای توجه از سوی ما را داشته باشید، این هم لازم است که نوع رفتار شما این شایستگی را نشان دهد — زیرک، اندیشمند، هشیار و علاقه‌مند به شرکت فعالانه در توسعهٔ یک راه‌حل. اگر شما نمی‌توانید با این شرایط سر کنید، ما پیشنهاد می‌کنیم که به شخصی برای قرارداد پشتیبانی تجاری پول پرداخت کنید، بجای اینکه از هکرها بخواهید که شخصاً کمک خود را به شما اهدا کنند.
اگر تصمیم گرفتید که از ما کمک بگیرید، پس نمی‌خواهید که یکی از آن بازنده‌ها (loserها) باشید. همین‌طور نمی‌خواهید که شبیه یکی از آنها به نظر برسید. بهترین راه برای گرفتن یک جواب سریع و خوب این‌است که آن را مانند یک شخص زرنگ و مطمئن بپرسید، شخصی که واقعاً نیاز به کمک در یک مشکل خاص دارد.
(از اصلاح و بهبود این راهنما استقبال می‌کنیم. می‌توانید پیشنهادات خود را به آدرس esr@thyrsus.com یا respond-auto@linuxmafia.com ایمیل کنید. توجه کنید اگرچه قصد نداریم این سند یک راهنمای جامع برای فرهنگ استفاده از اینترنت (netiquette) باشد، و عموماً پیشنهاداتی را که بطور خاص مربوط به استخراج پاسخ‌های مفید در یک انجمن (forum) فنی نیستند، رد می‌کنیم)
## پیش از اینکه پرسش کنید
پیش از پرسیدن یک سوال فنی با ایمیل، یا در یک گروه خبری، یا در میز چت یک وب‌سایت، این کارها را انجام دهید:.
- بکوشید پاسخ را با جستجو در ویکی‌پدیا و یا در مداخل ویکی سایت مربوطه پیدا کنید.
- بکوشید پاسخ را با جستجو در آرشیو انجمنی که می‌خواهید بفرستید، پیدا کنید.
- بکوشید پاسخ را با جستجو در وب پیدا کنید.
- بکوشید پاسخ را با خواندن manual (راهنما) پیدا کنید.
- بکوشید پاسخ را با خواندن FAQ (سوالات متداول) پیدا کنید.
- بکوشید پاسخ را با بازبینی یا آزمایش پیدا کنید.
- بکوشید پاسخ را با پرسیدن از یک دوست باتجربه پیدا کنید.
- اگر برنامه‌نویس هستید، سعی کنید پاسخ را با خواندن کدمنبع پیدا کنید.
وقتی پرسش می‌کنید، این حقیقت را نشان دهید که نخست این کارها را انجام داده‌اید؛ این به تصدیق این امر که شما یک فرد تنبل و کشندهٔ وقت مردم نیستید کمک می‌کند. حتا بهتر، نشان دهید که شما این چیزها را یاد گرفته‌اید. ما دوست داریم به افرادی جواب دهیم که می‌توانند از جواب‌ها یاد بگیرند.
از فنونی مثل جستجوی متن پیغام خطا را در گوگل، استفاده کنید (جستجو در گروه‌های گوگل علاوه بر صفحات وب). این ممکن باعث شود که بتوانید مستندات یا آن گروه خبری را اصلاح کنید. حتا اگر این اتفاق هم نیفتد، گفتن اینکه «من عبارت زیر را گوگل کردم، اما چیز امیدوارکننده‌ای پیدا نکردم» چیز خوبی برای یک گروه پستی یا خبری است، حداقل به این دلیل که ثبت می‌شود که جستجو کمکی نمی‌کند. همینطور این کار به افراد دیگری با مشکلات مشابه کمک می‌کند که به آن ریسمان هدایت شوند، از طریق پیوند عبارت‌های جستجو به چیزی که ممکن است شامل مشکل شما و ریسمان مربوط به راه‌حل آن باشد.
وقت بگذارید. انتظار نداشته باشد که بتوانید مشکل پیچیدهٔ خود را با چند ثانیه گوگل کردن حل کنید. FAQها را بخوانید و بفهمید. قبل از این‌که به سراغ متخصصان بروید، آرام و باتمرکز بنشنید و کمی در مورد مشکل خود فکر و گمانه‌زنی کنید. به ما اعتماد کنید، آنها می‌توانند از سوالات شما تشخیص دهند که چقدر مطالعه و فکر کرده‌اید، و اگر شما خود را آماده کرده باشید آنها تمایل بیشتری به کمک خواهد داشت. به یکباره انبار سوالات خود را شلیک نکنید فقط به خاطر این‌که نخستین جستجوی شما به هیچ جوابی نرسیده است (یا به جوابهای زیادی رسید).
پرسش‌تان را آماده کنید. به آن بیاندیشید. پرسش‌های شتابزده به پاسخ‌های شتابزده منجر خواهد شد، یا اصلاً به هیچ جوابی نمی‌رسد. هر چه بیشتر نشان دهید که برای حل مسئلهٔ خود قبل از درخواست کمک، فکر و تلاش کرده‌اید، همان‌قدر احتمال بیشتری خواهد رفت که واقعاً به شما کمک کنند.
از پرسش اشتباه، بپرهیزید. اگر سوالی که بر اساس فرض‌های ناقص و اشتباه است بپرسید، ممکن است یک هکر با این تصور که «یک سوال احمقانه است...» بخواهد به شما یک جواب لفظی و بی‌فایده بدهد، و به امید این‌که شما درس بگیرید از تجربهٔ گرفتن آنچه پرسیدید، نه آنچه مورد نیاز شما بود. هرگز فرض نکنید که شما مستحق پاسخ هستید. این‌طور نیست؛ به هر حال شما بهایی بابت خدمات پرداخت نکردید. شما وقتی می‌توانید به جواب برسید که یک سوال قابل توجه و برانگیزندهٔ ذهن بپرسید، سوالی که به‌طور ضمنی باعث کمک به تجربهٔ جامعه می‌شود، نه آن‌که فقط بصورت انفعالی خواستار دانش از دیگران باشید.
از طرف دیگر، روشن ساختن این‌که شما توانایی و تمایل کمک در روند حل مسئله را دارید، شروع بسیار خوبی است. «آیا کسی می‌خواهد منبعی معرفی کند؟»، «مثال من چه چیز کم دارد؟»، و « بهتر است چه وب‌سایتی را بررسی کنم؟» به احتمال بیشتری جواب خواهند گرفت نسبت به این سوال که «لطفاً روش دقیق کاری که باید انجام دهم را بنویسید.». چون[در حالت اول] شما این را روشن می‌سازید که اگر شخصی فقط مسیر صحیح را به شما نشان دهد واقعاً راغب به تکمیل فرایند [ی حل مشکل] هستید.
## وقتی سوال می‌کنید
انجمن خود را به دقت انتخاب کنید به این حساس باشید که کجا سوال مطرح می‌کنید. شما نادیده گرفته خواهید شد، یا بعنوان یک بازنده (loser) محسوب خواهید شد اگر:
* سوال خود را در یک عنوان از دور خارج شده (off topic) ارسال کنید.
* یک سوال بسیار ساده را در انجمنی که انتظار سوالات فنی پیشرفته دارند پست کنید. یا بالعکس.
* یک سوال مشترک را در چند گروه خبری ارسال کنید.
* یک ایمیل شخصی به کسی که نه سابقه آشنایی با شما دارد، و نه شخصاً مسئول حل مشکل شماست بفرستید.
هکرها سوالاتی را که بیجا در مکان خاصی پست شود پاک می‌کنند تا کانال‌های ارتباطی‌شان را از غرق شدن در بی‌ربطی حفظ کنند. شما نمی‌خواهید این اتفاق برایتان بیفتد؛ بنابراین اولین قدم انتخاب انجمن درست است. باز هم، گوگل و سایر روش‌های جستجوی وب، دوست شما هستند. از آنها استفاده کنید و صفحهٔ وب پروژه‌ای که بیشتر با سخت‌افزار و نرم‌افزار مورد اشکال شما ارتباط دارند. معمولاً آن به شما لینک‌هایی به یک لیست از FAQ (سوالات مکرراً پرسیده‌شده) می‌دهند، و همینطور لینک‌هایی به لیست پستی پروژه و آرشیو آنها. این لیست‌های پستی آخرین مکان‌هایی هستند که باید از آنها کمک بگیرید، در صورتی‌که تلاش کرده باشید (از جمله خواندن آن FAQها) و جواب خود را نیافته باشید. همچنین ممکن است صفحهٔ پروژه روش گزارش اشکال (bug report) را شرح داده باشد، یا یک لینک به یکی از آن‌ها داشته باشد؛ در این‌صورت، آن را دنبال کنید.
ارسال ایمیل به سوی شخص یا انجمنی که با آن آشنا نیستید، در بهترین حالت یک ریسک است. مثلاً فرض نکنید صاحب یک صفحهٔ‌وب حاوی اطلاعات، می‌خواهد مشاور رایگان شما باشد. در مورد این‌که آیا سوال شما مورد استقبال واقع می‌شود یا نه، حدس‌های خوشبینانه نزنید — اگر مطمئن نیستید آن را جای دیگری بفرستید یا این‌که از فرستادن آن خودداری کنید.
وقتی یک انجمن وب، گروه خبری یا لیست پستی را انتخاب کردید، به اسم به‌تنهایی زیاد اعتماد نکنید؛ به یک FAQ یا امتیاز نگاه کنید تا بررسی کنید که سوال شما on-topic است. قبل از پست کردن، کمی از ترافیک گذشته بخوانید تا در نتیجه به یک احساس (تصور) برسید از اینکه چه جور چیزهایی آنجا انجام می‌شود. در واقع این ایدهٔ بسیار خوبی است که قبل از پست کردن، در آرشیو آن گروه‌خبری یا لیست پستی یک جستجو بر کلمات کلیدی مربوط به مشکل خود انجام دهید. این کار ممکن است برای شما جوابی را پیدا کند، و اگر هم این‌طور نشود، حداقل باعث می‌شود که بتوانید یک سوال بهتر را تنظیم کنید.
همهٔ کانالهای کمک‌رسانی را به یکباره تیرباران نکنید، این کار مانند فریاد زدن است و مردم را عصبانی می‌کند. به آرامی از میان آنها گام بردارید.
بدانید که موضوع مورد بحث شما چیست! یکی از اشتباهات کلاسیک اینست که سوالاتی دربارهٔ رابط برنامه‌نویسی یونیکس یا ویندوز را در انجمنی بپرسید که علاقه‌مند به یک زبان یا کتابخانه یا ابزار قابل‌انتقال بین هردو (یونیکس و ویندوز) است. اگر نمی‌دانید که چرا این کار اشتباهی است، بهتر است اصلاً هیچ سوالی نپرسید، تا وقتی که قضیه را درک کنید.
عموماً سوالاتی که در یک انجمن عمومی و درست (بجا) پرسیده شوند، احتمال این‌که جواب مفید بگیرند بیشتر از آنهایی است که در جای خصوصی پرسیده می‌شوند. چندین دلیل برای این امر وجود دارد. یک دلیل ساده، مقدار منابع پاسخگو است. یکی دیگر تعداد بازدیدکنندگان است؛ هکرها ترجیح می‌دهند به سوالاتی جواب دهند که افراد بیشتری را آموزش دهد، تا سوالاتی که فقط به درد افراد کمی بخورد.
به وضوح، هکرهای چیره‌دست و سازندگان نرم‌افزارهای محبوب، همواره بسیار بیشتر از توان پاسخ‌گویی‌شان، پیغام‌های انبوه و بی‌هدف دریافت می‌کنند. شما با اضافه شدن به این سیل، یکی از آن موارد بسیار زیاد هستید، حتا مثل یک کاه از انبوهی که پشت شتر را می‌شکند. — حتا در موارد کمی، توسعه‌دهندگان پروژه‌های محبوب، پشتیبانی خود را قطع کردند چون خسارت ناشی از ترافیک شدید و بی‌جهت ایمیل شخصی‌شان تحمل‌ناپذیر شده بود.
## انجمن‌های وب و IRC که برای تازه‌کارها تهیه شده‌اند، معمولاً سریع‌تر جواب می‌دهند
ممکن است گروه کاربران محلی شما، یا توزیع لینوکس شما، یک انجمن وب یا کانال IRC را معرفی کند که تازه‌کارها می‌توانند از طریق آن کمک بگیرند. (در شهرهای غیر انگلیسی زبان، انجمن‌های تازه‌واردان احتمالاً هنوز لیست پستی هستند) این‌ها مکان‌های اولیهٔ خوبی برای پرسیدن هستند، بخصوص اگر فکر می‌کنید ممکن است گرفتار یک مشکل نسبتاً ساده یا رایج باشید. یک کانال IRC اعلام شده، یک دعوتِ باز برای پرسیدن سوالات است و معمولاً در همان زمان جواب می‌گیرند.
در واقع، آن برنامه‌ای که برای شما مشکل بوجود آورده، اگر آن برنامه را از یک توزیع رایج لینوکس گرفته‌اید، بهتر است سوال خود را در انجمن/لیست مربوط به آن توزیع بپرسید، قبل از این‌که در انجمن/لیست مربوط به پروژهٔ آن برنامه بپرسید. هکرهای آن پروژه ممکن است فقط بگویند که «از نسخهٔ ساخته‌شدهٔ ما استفاده کنید».
قبل از پست کردن در هر انجمن وب، بررسی کنید که آیا یک قابلیت جستجو در آن انجمن هست یا نه. اگر هست، دوبار کلمات کلیدی را برای چیزی شبیه مشکل خود جستجو کنید؛ این کار فقط ممکن است کمک کند. حتا اگر یک جستجوی کلی در وب هم انجام داده باشید (که بهتر است انجام داده باشید)، باز هم انجمن را جستجو کنید؛ ممکن است موتور جستجوگر وب شما اخیراً تمام این انجمن را فهرست‌نویسی (index) نکرده باشد.
پروژه‌ها یک تمایل فزاینده‌ای دارند برای این‌که پشتیبانی کاربران را از طریق یک انجمن وب یا کانال IRC انجام دهند، و ایمیلی که بیشتر برای ترافیک توسعه رزرو شده است (نه پشتیبانی کاربر). پس برای کمک‌گرفتن‌های مربوط به پروژه، به دنبال آن کانال‌ها باشید.
## بعنوان گام دوم، از لیست پستی پروژه استفاده کنید
وقتی پروژه‌ای یک لیست پستی توسعه دارد، سوال خود را در لیست پستی بنویسید نه به شخص توسعه‌دهندگان، حتا اگر گمان می‌کنید که می‌دانید چه کسی بهتر از همه می‌تواند به سوال شما جواب دهد. مستندات پروژه و صفحهٔ خانگی آن (در وب) را بررسی کنید تا آدرس لیست پستی پروژه را پیدا کنید، و از آن استفاده کنید. چندین دلیل خوب برای این خط‌مشی وجود دارد:
* اگر سوالی برای پرسش از یک توسعه‌دهنده، بقدر کافی خوب باشد، ارزش پرسیدن در کل گروه را هم دارد. برعکس، اگر گمان می‌کنید که سوال شما برای یک لیست پستی بسیار تکراری است، پس عذری هم برای آزار دادن توسعه‌دهندگان منفرد وجود ندارد.
* پرسیدن سوالات در لیست‌های پستی، بارِ جواب دادن را بین توسعه‌دهندگان تقسیم می‌کند. یک توسعه‌دهندهٔ منفرد (بخصوص اگر راهبر پروژه باشد) ممکن است آنقدر سرش شلوغ باشد که نتواند به سوال شما جواب دهد.
* بیشتر لیست‌های پستی، آرشیو می‌شوند، و آرشیوها را موتورهای جستجو فهرست‌نویسی (index) می‌کنند. اگر سوالتان را در لیست پستی بپرسید و جواب بگیرید، افراد دیگری که در آینده همان سوال را دارند می‌توانند سوال و جوابش را در وب پیدا کنند، بجای این‌که دوباره آن را بپرسند.
* اگر سوالات خاصی به نظر می‌رسند که دارند بارها پرسیده می‌شوند، توسعه‌دهندگان می‌توانند از آن اطلاعات استفاده کنند برای بهبود مستندات یا خود نرم‌افزار تا واضح‌تر باشد. اما اگر آن سوالات بصورت شخصی پرسیده شوند، هیچ‌کس تصویر کاملی از این‌که چه سوالاتی بیشتر از بقیه پرسیده می‌شوند ندارد. اگر یک پروژه هم برای «کاربر» و هم برای «توسعه‌دهنده» (یا «هکر»)، لیست پستی یا انجمن وب دارد، و شما با کد برنامه کاری ندارید (و با کد آن درگیر نمی‌شوید)، سوال خود را در لیست/انجمن مربوط به کاربر بپرسید. تصور نکنید که در لیست پستی توسعه‌دهنده مورد استقبال واقع خواهید شد، در حالی‌که احتمالاً آنها سوال شما را بعنوان یک پارزیت حساب می‌کنند که در جریان مباحثهٔ توسعه‌دهندگان گسستگی ایجاد می‌کند.
با این حال، اگر مطمئنید که سوال شما جزئی (و کم‌مایه) نیست، و طی چند روز جوابی در لیست/انجمن «کاربر» نگرفتید، از لیست پستی «توسعه‌دهنده» استفاده کنید. می‌توانید بخوبی مصلحت‌اندیش باشید و قبل از پست کردن، یکی دو روز آنجا (لیست پستی «توسعه‌دهنده») را زیر نظر بگیرید تا با جَو و عرف محلی آنجا آشنا شوید (در واقع این مصلحت خوبی برای هر لیست خصوصی یا نیمه‌خصوصی است).
اگر نمی‌توانید آدرس لیست پستی پروژه را پیدا کنید، و فقط آدرس نگهدارنده (maintainer) پروژه را می‌بینید، پیش بروید و سوال خود را برای نگهدارنده (maintainer) پروژه بنویسید. اما حتا در این حالت هم فرض نکنید که لیست پستی وجود ندارد. در ایمیل خود اشاره کنید که شما سعی کردید ولی نتوانستید لیست پستی مناسب را پیدا کنید. همینطور اشاره کنید که مخالفتی ندارید اگر پیغام شما به افراد دیگری منعکس شود (forward شود). (بعضی افراد معتقدند که ایمیل خصوصی باید خصوصی بماند، حتا اگر هیچ چیز محرمانه در آن نباشد. اگر اجازه دهید که پیغام شما forward شود، به طرف مقابل این انتخاب را می‌دهید که چطور با ایمیل شما رفتار کند[خودش جواب دهد یا به شخص دیگری بسپارد، یا مثلاً در یک لیست پستی یا انجمن قرار دهد])
## از عناوین پرمعنا و دارای موضوع مشخص، استفاده کنید
در لیست‌های پستی، گروه‌های خبری یا انجمن‌های وب، عنوانِ موضوع، فرصت طلایی شماست تا با حدود ۵۰ کاراکتر یا کمتر، توجه متخصصانِ قابل را جلب کنید. با یاوه‌هایی مثل «لطفاً به من کمک کنید»، آن را هدر ندهید (پیعام‌هایی با چنین این‌گونه عناوین، از طریق واکنش دور انداخته می‌شوند). سعی نکنید با عمق اضطراب خود، ما را تحت تأثیر قرار دهید؛ در عوض، از آن فضا برای یک توصیف بسیار مختصر از مشکل خود استفاده کنید.
یک قرارداد خوب برای عنوان موضوع‌ها، که تعدادی از سازمان‌های پشتیبانیِ فنی استفاده کرده‌اند، اینست که به شکل «شیء - اِشکال» باشد. قسمت «شیء» مشخص می‌کند که کدام چیز یا کدام مجموعه از چیزها با مشکل مواجه است، و قسمت «اِشکال» انحراف رفتار آن شیء از آنچه انتظار می‌رود را شرح می‌دهد.
**احمقانه:**
کمک! ویدئو روی لپ‌تاپ من درست کار نمی‌کند!
**هوشمندانه:**
مکان‌نمای خراب موس X.org 6.8.1، چیپست ویدئو Fooware MV1005 vid. chipset
Fooware MV1005 X.org 6.8.1 misshapen mouse cursor,
**هوشمندانه‌تر:**
مکان‌نمای موس X.org 6.8.1 روی چیپ‌ست ویدئو Fooware MV1005 - خراب است
X.org 6.8.1 mouse cursor on Fooware MV1005 vid. chipset - is misshapen
جریان نوشتن یک توصیف «شیء-اِشکال»، به شما کمک می‌کند که اندیشیدن خود را دربارهٔ مشکل با جزئیات بیشتر سازماندهی کنید. چه چیزی تحت تأثیر واقع شده؟ فقط مکان‌نمای موس، یا جزء گرافیکی دیگری هم هست؟ آیا این مخصوص نسخهٔ X.org از X است؟ مخصوص ورژن ۶٫۸٫۱ است؟ آیا مخصوص چیپست ویدئوی Fooware است؟ یا مدل MV1005؟ یک هکر که نتیجه را می‌بیند، فوراً می‌تواند بفهمد که شما با چه چیزی مشکل دارید، و در یک نگاه مشکل شما را بفهمد.
کلی‌تر، تصور کنید که به یک لیست از سوالات یک آرشیو نگاه می‌کنید، که فقط خطوط عنوان‌ها نمایش داده می‌شوند. عنوان پست خود را طوری انتخاب کنید که بخوبی سوال شما را منعکس کنید، تا شخص بعدی که آرشیو را جستجو می‌کند، بتواند دنبال آن ریسمان (thread) را بگیرد و به یک جواب برسد، بجای اینکه دوباره آن سوال را پست کند.
اگر شما یک سوال را در پاسخ می‌فرستید، مطمئن شوید که خط عنوان را تغییر دهید تا نشان دهد که در حال پرسیدن یک سوال هستید. یک خط عنوان مانند «پاسخ: تست» یا «پاسخ: باگ جدید» کمتر احتمال می‌رود که به قدر مفیدی توجه را جلب کند. همینطور در نقل قول پیام‌های قبلی، با حذف قسمتهای اضافه، آن را به حداقل برسانید تا با mail readerهای جدید سازگار باشد.
برای شروع یک ریسمان کاملاً جدید، به سادگی دکمهٔ پاسخ را فشار ندهید. با این کار، بازدیدکنندگان را محدود خواهید کرد. بعضی mail readerها مثل mutt به کاربر اجازه می‌دهند که بر اساس ریسمان مرتب کنند و سپس پیام‌های داخل یک ریسمان را با تا کردن آن پنهان کنند. افرادی که این کار را آنجا دهند هرگز پیام شما را نخواهند دید.
تغییر دادن عنوان، کافی نیست. Mutt و شاید دیگر mail readerها، برای تعیین یک ریسمان، به اطلاعات دیگری در سرآیند ایمیل‌ها نگاه می‌کنند، نه به خط عنوان. بجای این کار یک ایمیل کاملاً جدید را شروع کنید.
در انجمن‌های وب، قواعد رفتار خوب، کمی متفاوت است، چون پیام‌ها معمولاً خیلی بیشتر به یک بحث خاص محدود هستند، و معمولاً خارج از آن ریسمان‌ها (تاپیک‌ها) قابل مشاهده نیستند. هنگام پرسیدن یک سوال در پاسخ به ریسمان، تغییر دادنِ عنوان لازم نیست. حتا همهٔ انجمن‌ها اجازه نمی‌دهند که پاسخ‌ها بتوانند عنوان جداگانه‌ای داشته باشند، و اگر هم چنین کاری آنجا دهند تقریباً آنها را نمی‌خواند. به‌هرحال، پرسیدن یک سوال در یک پاسخ، به خودی خود مورد شک است، چون آن فقط توسط افرادی دیده خواهد شد که این ریسمان را دنبال می‌کنند. پس یک ریسمان (تاپیک) جدید را آغاز کنید، مگر اینکه مطمئنید می‌خواهید فقط از افرادی بپرسید که در حال حاضر در این ریسمان فعال هستند.
## پاسخ دادن را آسان کنید
پایان دادن به سوال با این عبارت که «لطفاً پاسخ خود را به ... بفرستید»، جواب گرفتن شما را کاملاً بعید می‌سازد. اگر حتا نمی‌توانید چند ثانیه به خودتان زحمت دهید که یک عنوان پاسخ-به در mail reader خود تنظیم کنید، ما هم نمی‌توانیم چند ثانیه به خودمان زحمت دهیم که دربارهٔ مشکل شما فکر کنیم. اگر نرم‌افزار ایمیل این امکان را نمی‌دهد، از یک mail reader بهتر استفاده کنید.
اگر سیستم‌عامل شما از هیچ mail reader ی که این امکان را بدهد، پشتیبانی نمی‌کند، از یک سیستم‌عامل بهتر استفاده کنید. در انجمن‌های وب، درخواست پاسخ از طریق ایمیل، کاملاً گستاخانه است، مگر این‌که معتقد باشید آن اطلاعات حساس هستند (و شخصی به هر دلیلی می‌خواهد آن را فقط به شما اطلاع دهد و نه به دیگران). اگر می‌خواهید هنگام پاسخ هر فرد، یک ایمیل کپی از آن به شما ارسال شود، از آن انجمن وب درخواست کنید که آن را برای شما ارسال کند؛ این امکان تقریباً همه جا تحت عناوینی مثل «این ریسمان را دنبال کن»، «هنگام پاسخ، ایمیل بفرست» و غیره، مورد پشتیبانی است.
## بصورت واضح، از لحاظ دستوری صحیح، و با املای صحیح بنویسید
ما به تجربه دریافتیم افرادی که نویسندگان بی‌دقت و نامرتبی هستند، در فکر کردن و کدنویسی هم بی‌دقت و نامرتب هستند. جواب دادن به افرادی که فکر نامرتب و شلخته‌ای دارند، چندان مفید نیست؛ ما ترجیح می‌دهیم وقت خود را جای دیگری صرف کنیم.
پس مهم است که سوال خود را واضح و خوب بیان کنید. اگر نمی‌توانید زحمت آن را بکشید، ما هم نمی‌توانیم به آن توجه کنیم. تمام سعی خود را بکنید تا زبان (بیان) خود را بهبود دهید (صیقل دهید). لازم نیست که رسمی و سنگین باشد — در واقع فرهنگ هکرها به آن طرز بیانی بها می‌دهد که غیررسمی، عامیانه و شوخ‌طبعانه و همراه با دقت و ظرافت باشد. اما آن باید دقیق باشد؛ باید نشانه‌هایی باشد که شما اندیشه و توجه می‌کنید.
املا، نشانه‌گذاری و بزرگ کردن حروف اول را درست انجام دهید. its را با it's و loose را با lose و discrete را با discreet اشتباه نگیرید. تمام حروف را بزرگ ننویسید؛ این مانند فریاد زدن تعبیر می‌شود و خشن تصور می‌شود. (اگر تمام حروف هم کوچک باشد، فقط کمی رنجش‌آور بوده و خواندن آن را سخت می‌کند)
کلی‌تر، اگر مانند یک انسان ساده و کم‌سواد بنویسید، بسیار احتمال می‌رود که نادیده گرفته شوید. پس از میانبرهایی که کوتاه‌کنندهٔ متن استفاده نکنید. نوشتن you بصورت u شما را شبیه یک انسان ساده و کم‌سواد می‌کند که می‌خواهد دو کلید کمتر فشار دهد.
اگر سوال خود را در انجمنی می‌پرسید که از زبان بومی شما استفاده نمی‌کند، شما یک میزان محدودی از خطاهای املایی و دستوری خواهید داشت، اما از روی تنبلی دچار خطاهای بیش از حد نشوید (بله، ما معمولاً می‌توانیم آن تفاوت را تشخیص دهیم). همینطور اگر نمی‌دانید که شخص پاسخگو چه زبانی دارد، به انگلیسی بنویسید. هکرهای مشغول، سوالات با زبانی که نمی‌فهمند را نادیده می‌گیرند، و انگلیسی زبان کاری اینترنت است. با نوشتن به زبان انگلیسی، این احتمال را که سوالتان بدون خوانده شدن پاک شود، به حداقل می‌رسانید.
## سوال خود را در قالب‌های استاندارد و در دسترس مطرح کنید
اگر پرسشتان را به طور مصنوعی سخت کنید، احتمال نادیده گرفتن آن بیشتر می‌شود لذا:
* نامه را با قالب "plaintext"و نه "HTML" بفرستید. (غیر فعال کردن HTML کار سختی نیست) ضمیمه‌های MIME معمولاً مناسب هستند اگر شامل مطالب واقعاً ضروری باشند.
* نامه خود را به صورت پاراگراف‌هایی که از خطوط به هم پیچیده شده تشکیل شده‌اند، نفرستید. این کار، پاسخ گویی به قسمتهای مختلف نوشته شما را دشوار می‌کند، فرض کنید که پاسخگویی شما، نامه شما را در صفحاتی با خطوط شامل ۸۰ کاراکتر می‌بیند، لذا خطوط خود را در ۸۰ کاراکتر یا کمتر تهیه کنید.
* داده‌های خود را مانند آدرس فایل‌ها به چند خط تبدیل نکنید تا در عرض یک ستون قرار گیرد. داده‌ها باید به همان صورتی که هستند در نامه قرار بگیرند تا خواننده مطمئن شود که چیزی را می‌بیند که شما قبلاً دیده‌اید.
* هرگز تصور نکنید که مخاطبین شما قادر به خواندن فایل‌های اختصاصی مانند Microsoft word یا Excel هستند. بسیاری از هکرها به این کار همانند وقتی که یک توده‌ای از کود که بوی خوک می‌دهد و در جلوی در باشد، به آن واکنش نشان می‌دهند و اگر هم بتوانند به آن غلبه کنند، این کار نمی‌کنند.
* اگر شما از سیستم‌عامل [[ٌWindows|ویندوز]] نامه می‌فرستید، امکان "smart Quotes" را غیر فعال کنید. این کار از فرستاده شدن کاراکترهای بی‌مصرف جلوگیری می‌کند.
* در صفحات گفتگو، از اشکال خندان (smiley) و امکانات HTML استفاده نکنید. یکی دو تا از این اشکال ایرادی ندارد اما اگر صورت نوشته شما با این گونه اشکال پر شده باشد، دیگران فکر می‌کنند که شما عاجز از نوشتن هستید. بطور جدی استفاده بیش از حد از این اشکال و رنگی کردن نوشته‌ها شما را شبیه دختر نوجوانی که در حال خندیدن است می‌کند که این کار عموماً برای شما جوابی به همراه ندارد.
اگر شما از یک پردازش‌گر ایمیل با صورت گرافیکی کاربری مانند MS Outlook, Netscape Messenger و یا از این‌گونه‌ها استفاده می‌کنید، آگاه باشید که در صورتی که از تنظیمات پیش‌فرض آن استفاده می‌کنید، ممکن است این قوانین نقض شوند.
بیشتر این پردازشگرها دارای یک دستور در فهرست خود به نام view source هستند از این گزینه در پوشه نامه‌های فرستاده خود استفاده کنید و فرستادن نوشته ساده (plain text) بدون ضمایم غیر ضروری را بررسی کنید.
## درباره مشکل خود دقیق و آگاه باشید
* نشانه‌های مشکل ایجاد شده یا bugها را به دقت و روشنی شرح دهید.
* محیطی که در آن این مشکل ایجاد می‌شود را شرح دهید. (سیستم عامل، کاربرد و ...) شرکت فروشنده و مدل آن‌را هم معرفی کنید مثلاً (Fedora Coret یا Slackware 91 و ...)
* مطالعاتی که بر روی این مشکل انجام داده‌اید را شرح دهید.
* مراحل تشخیص و رفع مشکل را که انجام داده‌اید، پیش از طرح سوال، شرح دهید.
* هرگونه تغییر در سخت‌افزار یا نرم‌افزار که اخیراً انجام شده است را شرح دهید.
* تلاش کنید تا به سوالاتی که پیش‌بینی می‌کنید از شما پرسیده شوند، پیش‌تر پاسخ دهید.
* Simon Tatham مقاله جالبی به نام [https://www.chiark.greenend.org.uk/~sgtatham/bugs.html «چگونه Bugها را به طور مؤثر گزارش کنیم»] نوشته است که قویاً توصیه می‌شود آن‌را بخوانید.
## حجم مطالب دلیلی بر دقیق بودن آن نیست
باید دقیق و آموزنده بنویسید. این هدف با نوشتن حجم زیادی از داده‌ها و کدها در نامه تقاضای کمک محقق نمی‌شود. اگر یک مشکل بزرگ و پیچیده دارید، سعی کنید آن‌را تا حد ممکن خلاصه و مرتب ارائه کنید.
این امر حداقل سه فایده دارد. اول این‌که معلوم شود که شما برای خلاصه کردن سؤال خود تلاش کرده‌اید یا تمایل بیشتری برای پاسخ به شما وجود خواهد داشت. دوم این‌که با خلاصه‌سازی پاسخ مفیدتری هم خواهید گرفت؛ و سوم این‌که در حین خلاصه کردن و پیرایش گزارش خود ممکن است بتوانید مشکل را حل کنید یا راه حل کوتاه‌تری برای آن پیدا کنید.
## ادعای یافتن یک bug را نکنید!
هنگامی که با یک نرم‌افزار به مشکل برخوردید، بدون اطمینان کامل ادعای یافتن یک bug جدید را مطرح نکنید. راهنمایی: تا هنگامی که با یک ضمیمه به کد منبع نتوانید مشکل را برطرف کنید یا با آزمایش رگرسیون با ورژن قبلی که نشان دهنده یک رفتار نادرست باشد، شما نباید مطمئن شوید. این امر در مورد وب سایت‌ها و مدارک هم صدق می‌کند سندی را به عنوان bug یافتید، باید متنی را جایگزین آن کنید یادآوری می‌شود که کاربران بسیاری هستند که مشکل شما را تجربه نکرده‌اند. همچنین شما با خواندن مطالب و وب سایت‌های مرتبط، در مورد آن نرم‌افزار آموزش دیده‌اید در غیر این صورت شما کاری را اشتباه انجام می‌دهید و نه نرم‌افزار.
افرادی که یک نرم‌افزار را تهیه می‌کنند، تلاش می‌کنند تا آن نرم‌افزار حداکثر کارایی مطلوب را داشته باشد. اگر شما ادعا کنید که یک bug در آن یافته‌اید، در واقع کامل بودن کار آنها را زیر سؤال برده‌اید و این باعث رنجاندن آنها می‌شود، حتا اگر حق با شما باشد. به خصوص ذکر کلمه bug در عنوان نامه، کار سیاست مدارانه‌ای نیست.
وقتی که سوال خود را مطرح می‌کنید، بهتر است فرض کنید که شما کار اشتباهی را انجام می‌دهید، حتا اگر مطمئن باشید که یک bug واقعی را یافته‌اید. اگر واقعاً این طور باشد، در مورد آن در پاسخ‌ها خواهید شنید. با این کار نگهدارنده‌های نرم‌افزار از شما عذرخواهی خواهند کرد، همچنین اگر شما اشتباه کرده باشید، باید از آنها عذرخواهی کنید.
## تحقیر کردن جایگزینی برای انجام تکلیف نیست
بعضی از افراد که می‌دانند نباید گستاخانه یا مغرورانه رفتار کنند، در نقطه مقابل تحقیر کردن، تقاضای جواب می‌کنند. جملاتی مثل «می‌دانم که یک کاربر جدید بازنده هستم ولی...» از این قبیل‌اند. این کار منحرف کننده است و کمکی هم نمی‌کند به خصوص این کار وقتی توأم با ابهام در مورد مشکل واقعی باشد، آزار دهنده است.
وقت خود و ما را با سیاست‌های خام و پیش پا افتاده هدر ندهید. در عوض، زمینه‌های واقعی مشکل خود را به وضوح شرح دهید. این کار بهتری نسبت به تحقیر کردن است.
برخی انجمن‌ها محل جداگانه‌ای برای سوال‌های کاربران تازه‌کار دارند. اگر فکر می‌کنید که سوال پیش پا افتاده‌ای دارید، به آنجا بروید. اما در آنجا نیز نباید تحقیر کرد.
## به جای حدس‌های خود نشانه‌های مشکل را شرح دهید
نوشتن در مورد اینکه خودتان علت مشکل پیش آمده را چه می‌دانید، مفید نیست (اگر فرضیات شما بکلی اشتباه باشد آیا با دیگران مشورت می‌کنید؟)
لذا سعی کنید که به دوستداران کامپیوتر از علائم و نشانه‌های اولیه مشکل موجود بگویید و نه از فرضیات و تئوری‌های خود. بگذارید
آنها خود تفسیر کنند و مشکل را تشخیص دهند اگر احساس می‌کنید که ذکر کردن حدستان می‌تواند مهم باشد، آن‌را به روشنی و با عنوان حدس بیان کنید و همچنین دلیل این‌که چرا این پاسخ نمی‌تواند جوابگوی مسئله باشد بیان کنید.
**سوال احمقانه:**
من دائماً پیغام خطای **SIG11** را در کامپایل کردن کرنل، دریافت می‌کنم و به یک شکاف بسیار نازک در بورد اصلی (Mothor Boord) مشکوک هستم. بهترین راه برای اطمینان از این وضعیت چیست؟
**سؤال هوشمندانه:**
کامپیوتر خانگی من که K 6233 بر روی بورد اصلی FIC-PA 2007 (VIA Apollo VP2 Chipcedt) با ۲۵۶ مگابایت رم از نوع Car Sair PC133 SDRAM می‌باشد، ۲۰ دقیقه بعد از روشن شدن دائماً پیغام خطای SIG11 را نشان می‌دهد. اما قبل از ۲۰ دقیقه هرگز این اتفاق نمی‌افتد. با Restart کردن سیستم، ساعت Restart نمی‌شود ولی با خاموش کردن در شب Restart می‌شود. با خارج کردن رم‌ها هم این مشکل حل نمی‌شود. قسمت مربوطه از فهرست کامپایل به شرح ذیل است.
چون رسیدن به این نقطه برای بسیاری از افراد مشکل به نظر می‌رسد، یک جمله را به شما یادآوری می‌کنیم: «همه تشخیص دهندگان از ایالت میسوری هستند!» که شعار اداری این ایالت «به من نشان بده» است. (در سال ۱۸۹۹ یکی از افراد کنگره آمریکا گفت من از کشوری می‌آیم که در آنجا ذرت و کتان و دموکرات و فصاحت بیان بی‌معنی کشت می‌کنند که نه مرا متقاعد می‌کند و نه راضی. من از ایالت میسوری هستم. شما باید به من نشان بدهید) در مورد تشخیص دادن، شک کردن مهم نیست اما نیاز واقعی و کاربردی به دانستن این است که چه چیزی به نشانه‌هایی که شما دیده‌اید نزدیک‌تر است و نه فرضیات و حدس‌های شما. به ما نشان بدهید!
## نشانه‌های مشکل خود را به ترتیب زمان وقوع شرح دهید
نشانه‌های مفید برای تشخیص اینکه چه مشکلی پیش آمده است، اغلب در اتفاقاتی که قبلاً افتاده‌اند وجود دارند؛ لذا باید به دقت شرح دهید که چه کاری انجام داده‌اید و سیستم و کامپیوتر شما چه عکس‌العملی داشتند تا اینکه سیستم ترکیده است.
در مورد فرآیندهای **Command-Line**، داشتن یک **Session log** و نقل قول مربوط در حدود بیست خط می‌تواند خیلی مفید باشد.
اگر برنامهٔ مشکل دار، دارای گزینه تشخیص عیب باشد (مانند حالت **verbose**) سعی کنید از آن برای گرفتن اطلاعات بیشتر برای اشکال‌زدایی (debug) برنامه استفاده کنید.
به یاد داشته باشید که لزوماً هر چه بیشتر، بهتر نخواهد بود. سعی کنید سطحی از اشکال‌زدایی را انتخاب کنید که خواننده را مطلع نماید و نه اینکه او را با انبوهی از داده‌های بی‌ارزش گمراه کند.
اگر نوشتهٔ شما طولانی شد (بیش از ۴ پاراگراف)، نخست بهتر است به طور مختصر مشکل را مطرح کنید و سپس به شرح وقایع به ترتیب زمانی بپردازید. به این شکل خوانندگان خواهند دانست که باید به دنبال چه چیزی بگردند.
## هدف را مشخص کنید، نه مرحله
اگر به دنبال این هستید که بدانید چطور باید کاری را انجام داد (مثل گزارش کردن یک اشکال یا ''' bug ''')، با شرح دادن هدف خود شروع کنید. بعد از آن فقط برخی از مراحل خاص که برای رسیدن به آن طی کردید و موفق نشدید را شرح دهید.
اغلب، افرادی که به کمک تکتیکی نیاز دارند، هدف بلند مرتبه‌ای را در ذهن می‌پرورانند و در راهی که فکر می‌کنند تنها راه رسیدن به هدف است گمراه می‌شوند. آنها برای کمک گرفتن مرحله به مرحله می‌آیند اما نمی‌دانند که مسیر اشتباه است تلاش قابل توجهی برای گذر از این مرحله مورد نیاز است.
**سوال احمقانه**:
چگونه می‌توان در برنامه **FooDraw** مقادیر **RGB** رنگ را بر مبنای شانزده‌تایی انتخاب کرد؟
**سوال هوشمندانه**:
من تلاش می‌کنم که جدول رنگ‌ها را روی یک تصویر با مقادیر انتخابی خودم قرار دهم. در حال حاضر تنها راهی که به نظرم می‌رسد اینست که هر ردیف از جدول را اصلاح کنم اما نمی‌توانم در برنامه **FooDraw** رنگ‌ها را بر مبنای مقادیر **RGB** شانزده‌تایی انتخاب کنم.
سوال دوم هوشمندانه بود. جواب این سوال ابزار بهتری برای آن کار را پیشنهاد می‌دهد.
## از دیگران نخواهید که پاسخ را به صورت خصوصی ایمیل کنند
کاربران اینترنت باور دارند که حل مشکلات باید یک فرایند عمومی و روشن باشد که در طی آن نخستین پاسخ به یک پرسش می‌تواند و باید توسط دیگر کاربران که با اطلاعات بیشتری به آن توجه می‌کنند مورد تصحیح و تکمیل قرار بگیرد.
همچنین، کسانی که کمک می‌کنند تا دیگران به پاسخشان برسند، بخشی از پاداش خود را به این صورت می‌گیرند که به عنوان فردی مسئول، پاسخگو و صلاحیت‌دار و مطلع از جانب دیگر کاربران دیده می‌شوند.
وقتی که شما به شکل خصوصی درخواست پاسخ می‌کنید، هم فرایند پاسخ‌گویی و هم این پاداش را دچار مشکل می‌کنید. این کار را نکنید. این انتخاب فرد پاسخگو است که به شما بطور خصوصی پاسخ دهد یا خیر و اگر او این کار را انجام دهد معمولاً به این دلیل است که فکر می‌کند سوال از لحاظ جذابیت برای دیگران و همچنین اطلاعات، برای دیگران بسیار ضعیف است.
تنها یک استثناء برای این قاعده وجود دارد. اگر فکر می‌کنید که سوال شما بگونه‌ای است که ممکن است جواب‌های بسیار زیاد و مشابه به یکدیگر دریافت کنید، از کلمات جادویی مانند «به من ایمیل بزنید و من خلاصه‌ای از پاسخ‌ها را به Group خواهم فرستاد» استفاده کنید. ممانعت از ورود تعداد بسیار زیاد نامه‌های مشابه یکدیگر به ''' Group '''' ها و یا **Mailing hist**ها کار مودبانه‌ای است اما باید به قول خود مبنی بر خلاصه کردن جواب‌ها عمل کنید.
## سوال را صریح مطرح کنید
برای سوال‌هایی که انتهای مشخصی ندارد، بازه زمانی محدودی برای پاسخگویی به آنها در نظر گرفته نمی‌شود. کسانی که می‌خواهند پاسخ‌های مفیدی به شما بدهند، مشغول‌ترین افراد هستند. (چون در اغلب کارها به تنهایی کار می‌کنند). این گونه افراد نسبت به سوال‌هایی با بازه زمانی نامحدود حساسیت دارند و تمایل چندانی به پاسخ‌گویی به آنها ندارند.
شما هنگامی که یک پاسخ مفید دریافت می‌کنید که از پاسخگویی خود در مورد چیزی که می‌خواهید بطور صریح پرسیده باشید (از اشاره‌گر استفاده کند، که بفرستید، پیوست را بررسی کنید یا هر چیز دیگر). این کار تلاش پاسخگو را بر روی هدف شما متمرکز می‌کند و به طور ضمنی حدی از نظر زمانی برای پاسخگویی و صرف انرژی برای کمک به شما ایجاد می‌کند. این کار خوبی است.
برای درک دنیایی که متخصصین در آن زندگی می‌کنند، به مهارت به عنوان یک منبع و زمان فراوان برای پاسخگویی به یک مورد کمیاب فکر کنید. هر چه زمان کمتری را برای پاسخگویی به سوال خود به طور ضمنی در نظر بگیرید، احتمال این‌که پاسخ واقعاً مناسب از جانب یک فرد خبره و پرمشغله دریافت کنید، بیشتر می‌شود بنابراین بهتر است که برای سوال خود قالبی در نظر بگیرید که زمان مورد نیاز به پاسخگویی به آن را از جانب یک فرد خبره به حداقل برساند. اما این کار اغلب مشابه ساده‌سازی یک سوال نیست. به عنوان مثال، ممکن است برای شرح مناسبی از X یک راهنمایی کنید؟ معمولاً سوال هوشمندانه‌تری است نسبت به اینکه ممکن است لطفاً X را توضیح دهید!
اگر شما یک کد نادرست دارید، بهتر است در مورد این‌که چه اشکالی دارد بپرسید تا اینکه درخواست کنید کسی آن‌را اصلاح کند.
## وقتی که در مورد کد می‌پرسید
بدون این‌که مشخص کنید که باید به دنبال چه نوع مشکلی بود، از دیگران نخواهید تا کد برنامهٔ شما را اشکال‌زدایی یا به اصلاح **debug** کنند. فرستادن چند صد خط برنامه و گفتن این‌که «این برنامه کار نمی‌کند!» باعث می‌شود که هیچ پاسخی دریافت نکنید با فرستادن ده دوازده خط از برنامه و گفتن این‌که بعد از خط هفتم انتظار داشتم که اتفاق X بیفتد ولی Y رخ داد! بیشتر احتمال دارد تا به پاسخ برسید.
## تکالیف منزل را نپرسید
کاربران کامپیوتر دریافتن پرسش‌هایی که از تکالیف منزل می‌شوند تبحر دارند. اغلب ما این کار را کرده‌ایم. این پرسش‌ها برای این است که روی آن‌ها کار کنید تا تجربه کسب کنید. پرسیدن راهنمایی ایرادی ندارد اما نه کل روش حل.
اگر دیدید که روی یک سوال کار کرده‌اید اما نتوانستید آن‌را حل کنید، از یک فروم یا گروپ بپرسید یا در نهایت به عنوان یک «کاربر» از لیست فروم یا پروژه کمک بگیرید با وجود اینکه کاربران دیگر متوجه آن می‌شوند، اما برخی از دیگر کاربران حرفه‌ای ممکن است حداقل یک راهنمایی به شما بکنند.
## پرسش‌های بی‌معنی را حذف کنید
از به پایان رساندن درخواست پرسش خود با جملات بی‌مفهومی مانند کسی می‌تواند به من کمک کند؟ یا آیا جوابی وجود دارد؟ پرهیز کنید. اولاً، اگر شرح خود را تا نیمه نوشته بودید، این گونه پرسش‌ها زائد هستند. دوماً، به دلیل زائد بودن آنها کاربران آنها را آزاردهنده تلقی می‌کنند و احتمال دارد که جواب‌هایی بی عیب و نقص ولی بی اعتنا مانند بله، به شما می‌توان کمک کرد. یا خیر، هیچ کمکی نمی‌توان کرد به شما بدهند.
به طور کلی، از پرسش‌های آری یا خیر باید اجتناب شود مگر این‌که تنها جواب بله یا خیر برای شما کافی باشد.
سوال خود را با کلمه «فوری» نشانه‌دار نکنید، حتا اگر برای شما اینگونه باشد: این مشکل شماست، نه دیگران. اظهار ضرورت کردن نتیجه معکوس می‌دهد. بیشتر کاربران به راحتی اینگونه سوال‌ها را که با خودخواهی و گستاخی درخواست توجه فوری و ویژه می‌کنند را حذف می‌کنند.
تنها یک شبه استثناء وجود دارد. اگر شما در یک محل با مرتبه بالا و با یک نرم‌افزار کار می‌کنید و از نظر زمانی تحت فشار هستید، گفتن مودبانه محدودیت زمانی خود می‌تواند مؤثر باشد تا دیگران را به پاسخ دادن به شما ترغیب کند.
البته این کار ریسک بالایی دارد، چون معیار جالب بودن مسائل از نظر کاربران دیگر با شما متفاوت است. به عنوان مثال فرستادن نامه از یک ایستگاه فضایی بین‌المللی قانع کننده است اما از جانب یک انسان با احساس خوب و مهربان یا یک سیاستمدار خیر. در واقع، نوشتن کلمهٔ «فوری» باعث می‌شود که از سوال شما دوری شود حتا اگر از نظر آنها مهم باشد.
اگر فکر می‌کنید که این امری مبهم است، دوباره این مطالب را بخوانید تا کاملاً آن‌را درک کنید، قبل از آن‌که نوشته‌ای را به جایی بفرستید.
## ادب ضرری ندارد، گاهی کمک هم می‌کند
مؤدب باشید. از جملاتی مانند «لطفاً» و «با تشکر از توجه شما» یا «ممنون از ملاحظه شما» استفاده کنید. به طور واضح بیان کنید از این‌که دیگران وقتشان را برای کمک به شما رایگان صرف می‌کنند، متشکرید.
صادق بودن، به اندازه واضح، دقیق، با دستور زبان صحیح و مشروح بودن و پرهیز از قالب‌های مالکانه، مهم نیست و حتا نمی‌تواند جایگزین آنها باشد. بطور کلی، کاربران علاقه دارند گزارش‌های دقیق تکنیکی از bugها و ایرادها را هر چند بی ادبانه دریافت کنند تا نوشته‌های مؤدب ولی ابهام‌آمیز. (اگر این امر برای شما مبهم است، به یاد داشته باشید که سوالها را با چیزی که توسط آن می‌توان یاد گرفت ارزش‌گذاری می‌کنند)
به هر حال اگر مشکلات تکنیکی خود را ردیف کنید، مؤدب بودن شانس شما را برای دریافت پاسخ مفید افزایش می‌دهد.
(باید ذکر شود که تنها مخالفتی که از سوی کاربران قدیمی نسبت به این نوشته دریافت کرده‌ایم، در رابطه با توصیه‌های قبلی ما برای تشکر پیشاپیش است. برخی از کاربران احساس می‌کنند که این دلالتی به منظوری دارد و نه تشکر. توصیه ما اینست که هم پیشاپیش تشکر کنید و هم بعد از پاسخ‌گویی و یا ادب و احترام را به روشهای دیگری بیان کنید قبلاً با جملاتی مثل: «با تشکر از توجه شما» یا «ممنون از ملاحظه شما».
## روش حل را با یادداشت مختصری پاسخ دهید
بعد از این‌که مسئله حل شد، یادداشتی به همه کسانی که به شما کمک کرده‌اند بفرستید، آنها را از نحوهٔ حل مطلع کنید؛ و باز هم از یاری آنها تشکر کنید. اگر مسئله شما در یک ایمیل لیست را گروه خبری مورد توجه قرار گرفته بود بهتر است این یادداشت را به آنجا بفرستید.
در بهترین حالت، پاسخ شما باید شامل سوال اولیه و به همراه کلمه حل شده یا Fixed یا Resolved یا هر کلمه‌ای با معنی مشابه در عنوان نامه باشد. در ایمیل لیست‌هایی که سرعت برگشت یا جواب دادن نامه‌ها زیاد است، یک کاربرد مستعد که می‌بینید یک نامه با عنوان مشکل X مطرح شده و سپس نامه مشکل X حل شده وجود دارد، وقت خود را (اگر علاقه‌مند به آن موضوع خاص نباشد) روی آن صرف نمی‌کند و به حل مشکلات دیگر می‌پردازد.
پاسخ شما نباید طولانی و شامل جملاتی ساده مثل: «ایراد از کابل شبکه بود، با تشکر از همه» باشد. حتا اگر پاسخ ندهید، بهتر از این جملات است. پاسخ کوتاه و خلاصه‌ای شیرین بهتر است از یک مقاله طولانی مگر اینکه عمق تکنیکی مسئله زیاد باشد. ذکر کنید که چه عملی مشکل را حل کرد اما لزومی ندارد که تمام مراحل حل مشکل را گزارش کنید.
برای برخی از مسائل مناسب است که خلاصه‌ای از مراحل رفع مشکل را گزارش کنید. وضعیت نهایی مسئله خود را شرح دهید. توضیح دهید چه روشی شما را به حل رساند و بعد از آن به داده‌هایی که جواب نمی‌رسد اشاره کنید. روش‌های اشتباه را باید بعد از جواب صحیح و دیگر مطالب خلاطه بیاورید تا این‌که خلاصه شما تبدیل به یک داستان کارگاهی نشود. از افرادی که به شما کمک کردند نام ببرید، با این کار با آنها دوست هم می‌شوید.
در کنار مؤدب و آموزنده بودن، این روش خلاصه نویسی به دیگرانی که در آرشیو ایمیل لیست‌ها، گروه‌های خبری و یا فروم‌ها به دنبال مطلبی هستند، کمک می‌کنید تا بدانند دقیقاً چه روشی به شما کمک کرده است.
در نهایت، این گونه خلاصه نویسی به تمام کسانی که کمک کرده‌اند، احساس رضایت‌مندی و نزدیکی به مسئله می‌دهد و این کم ارزش نیست. اگر شما یک تکنسین یا هکر نیستید، مطمئن باشید که این احساس برای راهنماها و متخصصینی که از آنها کمک گرفته‌اید، بسیار مهم است. شرح مسئله‌ای که به حل نشدن و پوچی ختم شود، مأیوس کننده است و کاربران از حل آنها خودداری می‌کنند. احساس دوری از این حالت کمک بسیار بسیار بزرگی به شما برای مرتبه بعدی که می‌خواهید سوال بپرسید می‌کند.
در نظر داشته باشید که چقدر می‌توانید دیگران را از داشتن مشکل مشابه پیشگیری کنید، از خود بپرسید که آیا یک سند نوشته یا FAQ (سوالات پرسیده شده متداول) می‌تواند کمک کند؟ و اگر جواب بله بود، آن‌را نوشته و بفرستید.
در میان کاربران حرفه‌ای، این گونه رفتار خلاصه نویسی مهم‌تر از ادب معمول است. این روشی است که با آن می‌توانید شهرتی بین دیگران برای تعامل با آنها کسب کنید که دارایی با ارزشی است.
## چگونه پاسخ‌ها را تفسیر کنیم
### RTFM و STFW: (یا) چگونه بیان کنیم که دچار مشکل جدی شده‌ایم
یک رسم سنتی و مقدس وجود دارد: اگر پاسخی دریافت کردید که در آن نوشته شده بود RTFM یعنی باید Manual (کتاب راهنما) را بخوانید. در این مواقع نظر فرد پاسخ دهنده معمولاً صحیح است. پس بروید دستورالعمل‌ها را بخوانید.
RTFM خویشاوندن جوانتری هم دارد. اگر پاسخ دریافتی شامل STFW بود یعنی آن فرد معتقد است که باید وب را جستجو کنید. مطمئناً حق با اوست.
پس بروید و جستجو کنید.
مدل مودبانه‌تر این بیان اینست که بگویند Google is your Friend یعنی گوگل دوست شماست و این یعنی در گوگل جستجو کنید.
در انجمن‌ها، ممکن است توصیه کنند که آرشیو را بگردید. در واقع، ممکن است فرد مهربانی، اشاره‌ای به مشکلات قبلی که این مسئله در آن‌جا حل شده است، کرده باشد. اما به این ملاحظات اعتماد نکنید، پیش از پرسش، آرشیو را جستجو کنید.
اغلب، هنگامی که افرادی به شما توصیه می‌کنند وب را جستجو کنید، در حین نوشتن از جملات، صفحه‌ای از دستورالعمل یا اطلاعاتی شما به آن نیاز دارید را در صفحه‌نمایش خود باز کرده‌اند و می‌بینند. این توصیه آنها به این معناست که
* اطلاعات مورد نیاز شما را به سادگی پیدا می‌شوند.
* اگر خودتان جستجو کنید بیشتر یاد می‌گیرید تا اینکه آن اطلاعات را به شما بدهند.
شما با این کار نباید رنجیده شوید. در استاندارد کاربران حرفه‌ای (هکرها)، پاسخ دهنده به پرسش شما بدین طریق نوعی از احترام خشن را نشان می‌دهد، به جای اینکه شما را نادیده بگیرد. در عوض شما باید به خاطر این مهربانی مادربزرگانه از او تشکر کنید.
### اگر نفهمیدید...
اگر پاسخ را نفهمیدید، فوراً تقاضای روشن کردن پاسخ نکنید. از همان اندازه‎هایی که برای پاسخ اولیه خودتان (دستورالعمل‎ها FAQS، وب و دوستان ماهر) برای فهمیدن جواب استفاده کنید. سپس اگر باز هم نیاز به شفاف سازی نشان دهید که چه چیزی یادگرفته‎اید.
برای نمونه تصور کنید که من به شما می‎گویم: "به‎نظر می‎رسد که شما Zentry گرفته شده‎ای دارید، باید آن‌را تمیز کنید." در این صورت یک جواب نامناسب این خواهد بود:"Zentry چیست؟" و یک جواب خوب این خواهد بود" بسیار خوب، من صفحه اصلی را خواندم و به Zentryها با عنوان سوئیچ‎های {{ic| -z}} و {{ic| -p}} اشاره شده است اما هیچ یک از تمیز کردن Zentry چیزی نگفته‎اند. آیا اینها درست است یا من نکته‎ای را متوجه نشده‎ام؟"
### برخورد با گستاخی
آنچه که در محیط هکرها گستاخی می‎نمایند به معنای توهین آمیزی نیست بلکه حاصل بیان مستقیم و بدور از مطالب اضافه است که برای افرادی که بیشتر به حل مسائل می‎اندیشیدند تا ایجاد احساس خوبی در دیگران، طبیعی‎تر است. وقتی با گستاخی مواجه شدید، سعی کنید آرام برخورد کنید. اگر کسی واقعاً از حد خود خارج شود بسیار متحمل است که یکی از افراد قدیمی آن لیست یا گروه جدی یا فروم او را متوجه کند. اگر این کار صورت نگیرد و شما خلق و خوی را از دست دهید ممکن است فردی را که طبق هنجارهای یک محیط کاربری افتاده کرده است از دست بدهید و شما مقصر خواهید بود. این امر شانس شما را در دریافت کمک برای آنچه که خواسته‎اید کاهش خواهد داد.
از طرف دیگر، معمولاً شما با گستاخی مواجه می‎شوید و برخورد با آن بی‎جا خواهد بود. حالت عکس فوق اینست که با متخلفین واقعی را به‎شدت برخورد کنید و رفتار غیر معقول آنها را با چاقوی کلام قطع کنید. البته قبل از کار از موقعیت خود بسیار بسیار مطمئن باشید مرز بین تصحیح دیگران و غیر فعال بودن و شروع یک جدال بی‎هدف به اندازه‎ای باریک است که خود هکرها هم گاهی اوقات آنرا اشتباه می‎گیرند. اگر شما یک تازه‌وارد هستید، شانس شما کمتر خواهد بود. اگر بدنبال اطلاعات هستید و نه سرگرمی، بهتر است انگشتانتان را از روی کی‎بورد بردارید و ریسک نکنید. (برخی افراد معتقدند که هکرها حالت خفیفی از خود ماندگی یا سندرم اسپرگر دارند و واقعاً فاقد برخی از مداربندی‎های مغزی آنها که برهم کنش‎های اجتماعی انسان را روان می‎کند، هستند. این ممکن است درست باشد یا نباشد اگر خودتان یک هکر نیستید، ممکن است از عهده بی‎قاعدگی و عجیب و غریب بودن این مسئله برآیید، اگر فکر می‎کنید که مغزما دچار ضایعه شده است. شروع کنید ما اهمیتی نمی‎دهیم! ترجیح می‎دهیم همان چیزی باشیم که هستیم و عموماً تردیدی نسبت به عناوین پزشکی داریم)
در قسمت بعد، در مورد مطلب متفاوتی بحث می‎کنیم با نوع گستاخی که در اثر رفتار اشتباه با آن برخورد می‎کنید.
## شبیه یک بازنده رفتار نکردن
با توجه به راه‎های مفصلی که در این‎جا گفته شد یا راه‎های مشابه بعید از که در فرم‎‎های ارتباطی هکرها اشتباه کنید. به‎طور دقیقی با جملات متفاوت به شما گفتیم که چگونه می‎توان اشتباه کرد.
گر چنین اتفاقی افتاد بدترین کار اینست که از این تجربه خود ناله کنید، ادعا کنید که شفاهاً مورد توهین قرار گرفته‎اید، تقاضای عذرخواهی کنید، جیغ بکشید، نقستان را حبس کنید، به شکایت کردن تهدید کنید، از افراد شکایت کنید و غیره. در عوض کاری که شما می‎کنید، اینست که:
* پیش بروید. این امری طبیعی است. درواقع مناسب و سالم است.
* استانداردهای جوامع از خودشان حمایت نمی‎کنند. توسط افراد فعالی که از آنها استفاده می‎کند و به‎وضوح در عموم حمایت می‎شوند. ناله نکنید که همه انتقادها باید در ایمیل‎های خصوصی عنوان شوند. اینگونه نیست. همچنین نباید اصرار کنید که توسط فردی که یکی از ادعاهای شما را اشتباه خوانده است یا نظر متفاوت است، مورد هجوم واقع شده‎اید. این اخلاق بازنده‎هاست.
* انجمن‌هایی هستند که در آنها به‎دلیل راهنمایی اشتباه و از روی ادب زیاد، شرکت‎کنندگان توسط دیگران کاربران از فرستادن نامه‎های گمراه کننده منع شده‎اند و به آنها گفته شده"اگر نمی‎خواهید به کسی کمک کنید، لطفا حرف نزنید!"
* رفتن کاربران راهنما به جاهای دیگر، منتج به این می‎شود که فروم به صحبتهای بلی‎معنی نزول کنند و تبدیل به یک؟ تکنیکی بی‎استفاده گردد.
* به‎طور اغراق‎آمیزی "دوستانه" (در این حالت) یا مفید: یکی را انتخاب کنید.
* به یاد داشته باشید: وقتی که هکری به شما می‎گوید که اشتباه کرده‎اید، (صرف نظر از اینکه چقدر درشت‎گویی کرده باشد)، به شما می‎گوید که دوباره آن کار را تکرار نکنید، او ملاحظه ۱- شما ۲- اجتماع را می‎کند. بسیار راحتتر است برای او که شما را ندیده بگیرد و شما را از زندگی خودش فیلتر کند. اگر نمی‎توانند سپاسگزار باشید، حداقل کمی بزرگی داشته باشید و ناله و شکایت نکنید و انتظار نداشته باشید که مثل یک عروسک شکننده با شما رفتار بشود زیرا شما یک تازه‌وارد با روحیه حساس و ادعاهای مبهم هستید.
گاهی اوقات افراد بدون هیچ دلیل روشنی شخصاً شما را مورد حمله قرار می‎دهند حتا اگر شما اشتباهی نکرده باشید (یا فقط در ذهن آنها دچار اشتباه شده‎اید) در این موارد، شکایت کردن روشی واقعاً اشتباه است.
این افراد متجاوز، نادان هم هستند که بدون هیچ دلیلی، خود را با تجربه می‎دانند یا با آزمایش‎های روان‎شناسی می‎خواهند بدانند که اشتباه کرده‎اید یا خیر. خوانندگان دیگر هم آنها را نادیده می‎گیرند و یا با روش خودشان با آنها برخورد می‎کنند رفتار این‎گونه افراد خود آنها را دچار مشکل می‎کند که به شما ربطی ندارد.
اجازه ندهید که داخل این‎گونه بحث‎ها به دام بیفتید. پس از این‌که بررسی کردید آنها واقعاً توهین هستند و نه اشاره‎ای به اشتباه شما و نه اشاره‎ای به اشتباه شما و نه اشاره‎ای زیرکانه به جواب واقعی سوال شما اغلب توهین‎ها نادیده گرفته می‎شوند.
## سوال‌هایی که نباید پرسید
در اینجا برخی از پرسش‌های احمقانهٔ معمول و سوال‌هایی که هکرها به آنها پاسخی نمی‎دهند، آورده شده است:
* سوال: کجا می‎توانم برنامه یا منبع X را پیدا کنم؟
* سوال: چگونه می‎توانم از X برای انجام کار Y استفاده کنم؟
* سوال: چگونه می‎توانم پوسته Prompt خود را تنظیم کنم؟
* سوال: آیا می‎توانم با تبدیل کننده Bass- O- Matic یک فایل Acme Corp را به Tex تبدیل کنم؟
* سوال: مسیر SQL statement و Configuration و Program من کار نمی‎کند!
* سوال: با [[Windows|ویندوز]] خود مشکل دارم. می‎توانید کمکم کنید؟
* سوال: برنامه من کار نمی‎کند. فکر می‎کنم وسیله X سیستم من خراب است!
* سوال: برای نصب [[گنو/لینوکس|لینوکس]] یا X مشکل دارم. می‎توانید کمکم کنید؟
* سوال: چگونه می‎توانم Crack کنم؟ حق امتیاز یک کانال را بدزدم؟ ایمیل کسی را بخوانم؟
----
* سوال: کجا می‎توانم برنامه یا منبع X را پیدا کنم؟
* جواب: از همان‎هایی که من پیدا کردم در پایان یک جستجوی اینترنتی. یعنی هنوز همه نمی‎دانند چگونه از google استفاده کنند؟
* سوال: چگونه می‎توانم از X برای انجام Y استفاده کنم؟
* جواب: اگر هدف شما انجام Y است نباید روشی را که ممکن است برای آن مناسب نباشد ذکر کنید. پرسش‌هایی از این قبیل اغلب نشانگر این هستند که فرد فقط در مورد X بی‎اطلاع نیست بلکه در مورد شکل ۲ که درحال حل آنست و در جزئیات موقعیت خاصی هم سردرگم شده است. بهتر است این‎گونه افراد را نادیده بگیریم تا وقتی‎که مشکل خود را بهتر مطرح کنند.
* سوال: چگونه می‎توانم پوسته Prompt خود را تنظیم کنم؟
* جواب: اگر به همان اندازه که برای پرسیدن این سوال باهوش باشید می‎توانید RTFM کنید و جواب خود را بیابید.
* سوال: می‎توانم یک فایل Acme Corp را به فایل Tex با تبدیل کننده Boss- O- matic تبدیل کنم؟
* جواب: امتحان کن و ببین اگر این کار را می‎کردی ۱- جواب را می‎یافتی ۲- وقت من را هم نمی‎گرفتی.
* سوال: مسیر SQL statement و Program/ Configuration من کار نمی‎کند.
* جواب: این سوال نیست و من علاقه‎مند نیستم که با بیست سوالی سوال واقعی را شما کاوش کنم. کارهای بهتری برای انجام دارم. وقتی چیزی شبیه این می‎بینم، عکس‎العمل من طبیعتاً یکی از موارد زیر خواهد بود:
1. چیز دیگری هم داری که به آن اضافه کنی؟
2. آه، چقدر بد! امیدوارم درستش کنی.
3. دقیقاً این چه ربطی به من دارد؟
* سوال: با ویندوز خود مشکل دارم می‎توانید کمک کنید؟
* جواب: بله آن تفاله مایکروسافت را بیرون بریز و یک سیستم عامل با منبع باز مثل Linux یا BSD نصب کن.
یادداشت: در مورد ویندوز و در مورد برنامه‎ای که ساخت رسمی ویندوز نیست یا با آن تداخل دارد (مثل Samba) سوال نپرس. از این جواب متعجب نباش چراکه مشکل از ویندوز است و نه برنامه چون‌که ویندوز به‎طور کلی بسیار آسیب‌پذیر است و این مورد معمولی است.
* سوال: برنامه من کار نمی‎کند. فکر می‎کنم وسیله X سیستم من خراب است.
* جواب: درحالی‌که ممکن است شما اولین مغزی باشید که به یک عیب واضح در سیستم توجه کرده باشید به کتابخانه‎هایی که توسط صدها یا هزاران نفر استفاده شده‎اند رجوع کنید؛ بهتر از اینست که بطور کلی بی‎دلیل بنویسید ادعاهای غیر معمول، شواهد غیر معمول هم لازم دارد وقتی ادعایی شبیه این می‎کنید، باید با مستندات واضح و جامع در مورد ایراد پشتیبانی کنید.
* سوال: برای نصب لینوکس یا X یا ... مشکل دارم می‎توانید کمک کنید؟
* جواب: خیر. باید دستم به سیستم شما برسد تا بتوانم مشکل را حل کنم. از گروه محلی کاربران Linux خود برای کمک بپرسید. (می‎توانید لیستی از گروههای کاربران را اینجا پیدا کنید)
یادداشت: سوال در مورد نصب Linux هنگامی‎که در ایمیل لیست یا فرومی در مورد یک توزیع خاص باشید مناسب است، یا در فرم‎های محلی کاربران. در این موارد، جزئیات مشکل را شرح دهید. اما قبل از آن جستجوی دقیقی با "Linux" و همه قطعات سخت‎افزاری مشکوک انجام دهید.
* سوال: چگونه می‎توانم Crack حق امتیاز یک کانال را بدزدم؟ ایمیل کسی را بخوانم؟
* جواب: شما زندگی سطح پایینی دارید که می‎خواهید این کارها را انجام دهید و یک انسان سبک‌مغز هستید که از یک هکر چنین چیزی می‎پرسید.
## پرسش‌های خوب و بد
در آخر، قصد دارم که با نمونه‌هایی روش پرسیدن هوشمندانه را شرح دهم.
جفتی از سوالها درباره یک مشکل یکسان، یکی از راه احمقانه و دیگر هوشمندانه.
* **احمقانه**: کجا می‎توانم چیزی درباره Foonly Flarbamatic پیدا کنم؟
این سوال فقط تقاضای یک (STFW" (Search the Fucking Web" در جواب دارد.
* **هوشمندانه**: از گوگل برای یافتن "Foonly Flurbumatic 2600" استفاده کردم، اما راهنمایی مفیدی نیافتم. می‎توانم راهنمایی در مورد اطلاعات برنامه‎نویسی روی این وسیله بگیرم؟
این مورد اکنون STFW را انجام داده است و به نظر می‎رسد که مشکل واقعی دارد.
* **احمقانه**: نمی‎توانم کد را از فلان پروژه برای کامپایل بگیرم. چرا خراب است؟
این پرسشگر فرض می‎کند که کس دیگری اشتباه کرده است خودبین...
* **هوشمندانه**: کدهای فلان پروژه تحت Nulix ورژن ۶٫۲ کامپایل نمی‎شود. من FAQ را خوانده‎ام اما چیزی درمورد مسائل مربوط به Nulix نداشت. در اینجا نسخه‎ای از تلاش برای کامپایل کردن را آورده‎ام آیا کاری انجام داده‎ام؟
پرسشگر این سوال محیط را مشخص کرده است FAQ را خوانده است خطا را نشان داده است؛ و فرض نمی‌‎کند که شکل او اشتباه دیگری باشد. این مورد ارزش توجه را دارد.
* **احمقانه**: با مادربورد خود مشکل دارم کسی می‎تواند کمک کند؟
پاسخ هکر J. Randem به این سوال اینست:"درست است. آیا نیاز دارید آروغ بزنید و پوشکتان عوض شود؟" که با زدن کلید Delete پایان می‎یابد.
* **هوشمندانه**: روی مادربورد t,y,x,s2464 را امتحان کردم. وقتی کمکی نکرد روش‌های C و B و A را امتحان کردم. هنگام امتحان روش C نشانه‎های غیر معمول را یادداشت کردم به‎طور مشخص اشکال از برنامه‎نویسی است اما نتایج طبق انتظار نیست. دلایل معمول ایرادهای مادربوردهای athlon MP کدامند؟ کسی ایده‎ای برای امتحان بیشتر مادربورد برای حل این مشکل دارد؟
از طرف دیگر این فرد ارزش پاسخ را دارد. او هوش حل مسئله خود را نشان داد. نه اینکه منفعلانه منتظر جوابی از بالا باشد.
در پرسش آخر دقت کنید به تفاوت زیرکانه ولی مهم بین درخواست کردن «جوابی به من بدهید» و «لطفا به من کمک کنید تا بدانم چه تشخیص‎های دیگری می‎توانم بدهم تا به آگاهی برسم» در واقع حالت سوال آخر بسیار نزدیک به یک رویداد واقعی که در آگوبیت ۲۰۰۱ در ایمیل لیست (lkml) Linux- kemel اتفاق افتاد بنا شده است. من (اریک) در آن زمان یک سوال پرسیدم. من قفل شدن‎های عجیبی در مادربورد S2462 Tyon می‎دیدم. اعضای لیست اطلاعات ضروری که برای حل به آنها نیاز داشتم که تأمین کردند.
به روشی که من سوالم را پرسیدم، به افراد چیزی برای تامل کردن دادم؛ راه را برای وارد شدن آنها آسان و جذاب کردم. من برای توانایی سایرین احترام قائل شدم و آنها را برای مشورت با من به‎عنوان یک دوست دعوت کردم. همچنین برای زمانی که آنها برای نشان دادن روشهای اشتباه به من صرف کردند احترام قائل شدم.
پس از آن، وقتی‎که از همه سپاسگزاری و یادآوری کردم که چه خوب فرایند حل شد، یکی از اعضای lkml مشاهده کرد که این مسئله نه به این خاطر که من یک «اسمی» در لیست داشتم حل شده است، بلکه به این‎خاطر که من سوال را به روش مناسبی پرسیدم.
هکرها از برخی جهات خیلی ظالم‎اند. من مطمئن هستم که اگر مانند یک انگل رفتار می‎کردم، به من توهین می‎شد یا اینکه مرا نادیده می‎گرفتید بدون توجه به اینکه من چه‎کسی هستم. پیشنهاد او برای نوشتن کل ماجرا به‎عنوان یک دستور‎العمل به دیگران مستقیماً موجب شد تا این راهنما را بنویسیم.
## اگر نتوانستید پاسخی بدست آورید
اگر نتوانستید جوابی بیابید لطفاً ناراحت نشوید که ما احساس نمی‎کنیم که می‎توانیم به شما کمک کنیم. گاهی اوقات اعضای گروهی که شما از آنها سوالی پرسیده‎اید ممکن است جواب را ندانند ندادن جواب به معنای نادیده گرفتن نیست، اگرچه مسلماً تشخیص بین این دو سخت است.
بطور کلی، دوباره فرستادن سوال ایدهٔ بدی است. این کار آزاردهنده و غیر مودبانه به‎نظر می‎رسد. صبر داشته باشید: کسی که جواب شما را می‎داند ممکن است در منطقه زمانی دیگری و خواب باشد. یا شاید سوال شما به حدکافی خوب شکل نگرفته باشد تا بتوان با آن شروع کرد.
مراجع دیگری برای کمک به شما هستند که اغلب به نیاز تازه‌واردها بهتر جواب می‎دهند. گروههای کاربری محلی و آن لاین بسیاری هست که مشتاق نرم‎افزار هستند حتا اگر هیچ‎گاه خودشان نرم‎افزاری ننوشته باشند. این گروه‎ها معمولاً به این دلیل شکل می‎گیرند که بتوانند به یکدیگر و تازه‌وارد کمک کنند.
همچنین شرکت‎های تجاری بسیاری هستند که می‎توانید برای کمک گرفتن با آنها تماس بگیرید، چه بزرگ و چه کوچک (SpikeSource , RedHat دو تا از بهترین آنها هستند، موارد بسیار دیگری نیز هست). از اینکه باید برای کمک گرفتن، پولی بپردازید مضطرب نشوید! اگر موتور ماشین شما واشرسرسیلندر بسوزاند(واشر زده‌باشد)، باید به تعمیرگاه بروید و برای تعمیرش پول بپردازید.
حتا اگر نرم‎افزار برای شما هزینه‎ای در بر نداشته باشد، نباید انتظار داشته باشید که پشتیبانی هم همیشه مجانی باشد.
برای نرم‎افزارهای معروف مانند Linux، حداقل ۱۰۰۰۰ کاربر برای هر نمایندگی وجود دارد. برای یک نفر ممکن نیست که تماس ۱۰۰۰۰ نفر را پشتیبانی کند. یادآوری می‎کنیم که حتا اگر مجبور شوید برای کمک پول بپردازید، هنوز دارید پول کمتری نسبت به آنچه که باید برای خرید نرم‎افزاری می‎پرداختید، می‎پردازید (پشتیبانی برای نرم‌افزار با منبع بسته معمولاً گرانتر و با صلاحیت کمتری نسبت به یک نرم‎افزار با منبع باز است)
## چگونه به پرسش‌ها مفید پاسخ بدهیم
آرام باشید. پرسش‌هایی که با تنش همراه باشند، باعث می‎شوند افراد احمق و یا گستاخ جلوه کننده حتا اگر واقعا این‎طور نباشد.
به نخستین متخلف به‎صورت Off- Line پاسخ دهید. هیچ نیازی به تحقیر کسی که اشتباه صادقانه‎ای را مرتکب شده است، در جمع عمومی نیست یک تازه‌وارد واقعی شاید نداند که چگونه آرشیو را جستجو کند یا پرسش‌های پرتکرار کجا ذخیره می‎شوند. اگر واقعاً نمی‎‎دانید، بگویید! یک پاسخ اشتباه ولی ظاهراً موثق بدتر از اینست که چیزی گفته نشود به کسی به گونه‎ای اشاره نکنید که او تحقیر شود چون فقط می‎خواهید مانند یک فرد ماهر به‎نظر بیایید متواضع و صادق باشید، مثال خوبی برای سوال کننده و همتایان خود بزنید.
اگر نمی‎توانید کمک کنید، مانع از کمک هم نشوید. روش‌ها را به شوخی نگیرید که ممکن است ساختار کاربر را به شوخی نگیرید که ممکن است ساختاری کاربر را از بین ببرد، یک کاربر ضعیف ممکن است این‎ها به‎عنوان دستور‎العمل تلقی کند.
پرسش‌ها کاوش گر هستند. بپرسید تا جزئیات بیشتری را استخراج کند. اگر در این کار ماهر هستید، سوال کننده چیزی یاد خواهد گرفت و همچنین شما سعی کنید سوال بد را به خوب تبدیل کنید. یادمان باشد که همه ما زمانی تازه‌وارد بودیم.
در هنگام خواندن RTFM گاهی اوقات خوب است به کسی که تنبل و نامرتب است یک راهنمایی به مستندات بکنیم (حتا اگر یک پیشنهاد برای عبارت کلیدی جستجو در گوگل باشد)
اگر به دنبال پاسخ دادن به پرسش هستید ارزش خوبی به آن بدهید. به کسی که روش یا ابزار اشتباهی را بکار گرفته، برای دور زدن مسئله ندهید. ابزار مناسب را پیشنهاد کنید. سوال را دوباره قالب‎بندی کنید.
به جامعه خود برای یادگرفتن از سوال کمک کنید. وقتی که سوال خوبی دارید، از خودتان بپرسید، "چگونه می‎توان اسناد و FAQهای مرتبط را به‎گونه‎ای تغییر داد که دیگر کسی دوباره این سوال را نپرسد؟" سپس یک ضمیمه برای اسناد (به نگهدارنده سایت بفرستید).
اگر برای پاسخ پژوهشی انجام داده‎اید، مهارت‌هایتان را نشان دهید به‎جای این‌که وانمود کنید جواب را از جیب خود درآورده‎اید. جواب دادن به یک سوال خوب، مانند غذا دادن به یک فرد گرسنه است اما آموختن روش‎ها و مهارت‌های تحقیق توسط مثال به آنها مانند نشان دادن راهی برای کاشتن غذا برای یک عمر است.
## پیوند به بیرون
چگونه هکر شویم. https://linuxbook.ir/chapters/being_hacker.html
# منبع
http://catb.org/esr/faqs/smart-questions.html

49
fa/ویم.md Normal file
View file

@ -0,0 +1,49 @@
---
title: ویم
description: معرفی و آموزش کوتاه ویرایشگر ویم (Vim)
published: true
date: 2025-02-18T17:28:01.796Z
tags: vim, ویم, vimscript
editor: markdown
dateCreated: 2025-02-18T17:27:58.851Z
---
# ویم
## معرفی
ویم (به انگلیسی: Vim) (سرنام عبارت vi improved به معنای وی‌آی بهبود یافته) یک ویرایشگر متن است که توسط برام مولینار در سال ۱۹۹۱ برای رایانه‌های آمیگا عرضه شد. این نام‌گذاری به این دلیل است که ویم به عنوان یک گسترش‌دهندهٔ ویرایشگر وی‌آی توسعه داده شده بود. ویم در آغاز برای رایانه‌های آمیگا منتشر شده بود؛ اما پس از آن به سوی چندسکویی پیش رفت.
ویم یک پروژهٔ نرم‌افزاری متن‌باز است. مولینار، نویسندهٔ آن، برای حمایت از کودکان اوگاندا کاربران را تشویق به بخشش برای مؤسسهٔ خیریه‌ای می‌کند که به آن کودکان یاری می‌رساند.
از دلایل علاقهٔ توسعه دهنده‌ها به ویم این است که افزونه پذیر (extensible) است و افزونه‌های زیادی برای ویم وجود دارد؛ مثلاً نردتری (NERDTree) که یک نمایشگر فایل درختی است یا vim-jedi که یک افزونهٔ کامل کنندهٔ کد است.
همین‌طور ویم کلیدهای ترکیبی دارد که می‌تواند خیلی کارها را اتوماتیک کند؛ مثلاً می‌شود با تایپ سه حرف، پنج کلمه را پاک کرد و برای افرادی که مدت طولانی از ویم استفاده می‌کنند مثل توسعه‌دهنده‌ها می‌تواند خیلی مفید باشد.
## تاریخچه
پیش‌درآمد برنامه Vim برنامه Stevie (ویرایشگر ST برای VI Enthusiasts) بود که در سال ۱۹۸۷ توسط تیم تامپسون برای Atari ST ایجاد شد و توسط تونی اندروز و GR (فرد) والتر توسعه یافت.
در سال ۱۹۸۸ برام مولنار بر پایه تجربه کاری خود بر روی Stevie، کار بر روی Vim را برای کامپیوتر آمیگا آغاز کرد و در سال ۱۹۹۱ اولین نسخه عمومی آن را منتشر کرد (Vim v1.14).
در زمان اولین انتشار، نام "Vim" مخفف "Vi IMitation" بود، اما این نام در اواخر سال ۱۹۹۳ به "Vi IMproved" تغییر کرد.
## نصب
برای نصب در پارچ از این دستور استفاده کنید:
```bash
sudo pacman -S vim
```
## آموزش
برای آموزش کار با ویم از vimtutor که به همراه ویم نصب شده است استفاده کنید
```bash
vimtutor
```

108
fa/پارچ-موبایل.md Normal file
View file

@ -0,0 +1,108 @@
---
title: دماوند
description: پارچ موبایل (دماوند)
published: true
date: 2025-02-09T12:07:24.928Z
tags: پارچ لینوکس, پارچ موبایل
editor: markdown
dateCreated: 2025-02-09T11:27:19.377Z
---
# **پارچ موبایل (اسم رمز: دماوند)**
**پارچ موبایل** (با اسم رمز **دماوند**) یک توزیع لینوکس برای گوشی‌های هوشمند است که به‌عنوان نسخه‌ی موبایلی **پارچ لینوکس** توسعه یافته است. **پارچ لینوکس** (مخفف **پرشین آرچ**) خود یک توزیع **آرچ بیس** است که با هدف ایجاد یک سیستم‌عامل **مینیمال، انعطاف‌پذیر و سبک** برای کاربران فارسی‌زبان و توسعه‌دهندگان لینوکس ساخته شده است.
**پارچ موبایل** همان ایده‌ها و اصول **پارچ لینوکس دسکتاپ** را به دنیای موبایل می‌آورد و به کاربران اجازه می‌دهد که از یک **سیستم‌عامل کاملاً متن‌باز و مینیمال** روی گوشی‌های هوشمند خود استفاده کنند. این پروژه از **کرنل مین‌لاین** (Mainline Kernel) بهره می‌برد و تلاش دارد تا جایگزینی آزاد برای سیستم‌عامل‌های بسته‌ی موبایلی ارائه کند.
## **توسعه و پشتیبانی**
پارچ موبایل توسط **جامعه‌ی پارچ لینوکس** توسعه داده می‌شود و در حال حاضر در **مراحل اولیه‌ی توسعه** قرار دارد. مانند پروژه‌های مشابهی نظیر **PostmarketOS** و **Mobian**، این توزیع هنوز در حال تکمیل ابزارهای لازم برای یک تجربه‌ی پایدار روی گوشی‌های موبایل است. هدف این پروژه، ارائه‌ی یک محیط کاملاً **متن‌باز، انعطاف‌پذیر و کنترل‌شده توسط کاربر** است که به کاربران اجازه می‌دهد بدون وابستگی به سیستم‌عامل‌های بسته، از یک **لینوکس واقعی** روی موبایل خود استفاده کنند.
پارچ موبایل بر پایه‌ی **آرچ لینوکس** ساخته شده و از **مدیریت بسته‌ی Pacman** بهره می‌برد. این یعنی کاربران می‌توانند همان تجربه‌ی مدیریت بسته‌ی آرچ را روی موبایل خود داشته باشند و از مخازن گسترده‌ی نرم‌افزاری آن استفاده کنند.
### تاریخچه توسعه
پارچ موبایل در ابتدا به عنوان یک انشعاب از پارچ آرم که در سال ۱۴۰۲ ایجاد شد در تیم پارچ مورد بحث قرار گرفت و در انتهای سال ۱۴۰۲ بر روی PocoPhone F1 با استفاده از کرنل پست‌مارکت او اس اجرا شد.
سپس در سال ۱۴۰۳ پارچ موبایل بر روی دستگاه‌هایی نظیر Poco X3 Pro و همچنین PinePhone نیز اجرا شده و اکنون به عنوان یک بخش جدی از اکوسیستم پارچ درحال توسعه است.
## **ویژگی‌ها و قابلیت‌ها**
پارچ موبایل ویژگی‌هایی را ارائه می‌دهد که آن را از سایر سیستم‌عامل‌های موبایلی متمایز می‌کند:
### **۱. کرنل مین‌لاین**
یکی از مهم‌ترین ویژگی‌های پارچ موبایل، استفاده از **کرنل مین‌لاین** است. برخلاف بسیاری از توزیع‌های لینوکسی موبایل که از کرنل‌های قدیمی و دستکاری‌شده‌ی اندروید استفاده می‌کنند، پارچ موبایل از کرنلی بهره می‌برد که به‌صورت مستقیم در پروژه‌ی اصلی **لینوکس مین‌لاین** توسعه می‌یابد. این باعث بهینه‌سازی بهتر، پایداری بیشتر و امنیت بالاتر در مقایسه با کرنل‌های بسته و قدیمی می‌شود.
### **۲. سیستم‌عامل مینیمال و سبک**
مانند نسخه‌ی دسکتاپ پارچ لینوکس، پارچ موبایل نیز **یک توزیع مینیمال و سبک** است که به کاربران اجازه می‌دهد کنترل کاملی روی سیستم داشته باشند. هیچ‌گونه **بسته‌ی غیرضروری یا نرم‌افزارهای اضافه** به‌صورت پیش‌فرض نصب نیست و کاربر می‌تواند سیستم خود را دقیقاً مطابق نیازهایش شخصی‌سازی کند.
### **۳. مدیریت بسته‌ی Pacman**
همانند **آرچ لینوکس**، پارچ موبایل نیز از **مدیریت بسته‌ی Pacman** استفاده می‌کند که یکی از سریع‌ترین و قوی‌ترین مدیر بسته‌ها در دنیای لینوکس است. این امکان باعث می‌شود کاربران بتوانند به‌راحتی بسته‌های مورد نیاز خود را نصب و به‌روزرسانی کنند.
### **۴. انعطاف‌پذیری بالا و پشتیبانی از شخصی‌سازی**
پارچ موبایل به کاربران پیشرفته این امکان را می‌دهد که سیستم‌عامل خود را کاملاً مطابق میلشان تنظیم کنند. کاربران می‌توانند **میزکارهای مختلف، بسته‌های نرم‌افزاری دلخواه را روی گوشی خود اجرا کنند.
## **پشتیبانی از دستگاه‌ها**
در **فاز اولیه**، پارچ موبایل به‌طور رسمی برای **۵ دستگاه مین‌لاین** عرضه خواهد شد. این دستگاه‌ها به‌گونه‌ای انتخاب شده‌اند که از **کرنل مین‌لاین** پشتیبانی کنند و بتوانند بهترین تجربه‌ی ممکن از پارچ موبایل را ارائه دهند.
در آینده، کاربران خواهند توانست **پارچ موبایل را از طریق PostmarketOS یا Mobian روی دستگاه‌های دیگر پورت کنند**. این یعنی اگر دستگاه شما به‌صورت رسمی پشتیبانی نشود، همچنان می‌توانید با کمی کار روی آن، پارچ موبایل را اجرا کنید.
## **مقایسه با پروژه‌های مشابه**
پارچ موبایل در دسته‌ی توزیع‌های **لینوکس موبایلی متن‌باز** قرار می‌گیرد که هدفشان ارائه‌ی جایگزینی برای سیستم‌عامل‌های بسته مانند **اندروید و iOS** است. برخی از پروژه‌های مشابه عبارتند از:
- **PostmarketOS** یک توزیع لینوکس سبک برای موبایل که بر پایه‌ی Alpine Linux ساخته شده است.
- **Mobian** نسخه‌ی موبایلی Debian که برای گوشی‌های لینوکسی توسعه داده شده است.
- **Ubuntu Touch** توزیعی از اوبونتو که برای موبایل توسعه یافته اما بر پایه‌ی کرنل‌های اندرویدی است.
برخلاف برخی از این پروژه‌ها، پارچ موبایل کاملاً **آرچ بیس** است و از **مدیریت بسته‌ی Pacman** و مخازن رسمی آرچ لینوکس بهره می‌برد. همچنین، استفاده از **کرنل مین‌لاین** آن را به گزینه‌ای آینده‌نگرانه‌تر تبدیل می‌کند.
## **ویژگی‌های اختصاصی پارچ موبایل**
پارچ موبایل علاوه بر ویژگی‌های استاندارد یک توزیع آرچ بیس، مجموعه‌ای از **ابزارهای اختصاصی** را نیز در اختیار کاربران قرار می‌دهد که تجربه‌ی کاربری را به سطح بالاتری می‌برد.
### **۱. پاستور (PaStor) استور رسمی پارچ لینوکس**
پاستور (PaStor) استور اختصاصی پارچ لینوکس است که امکانات پیشرفته‌ای را برای **مدیریت و نصب نرم‌افزارها** در اختیار کاربران قرار می‌دهد. برخلاف سایر توزیع‌های لینوکسی که فقط یک روش محدود برای نصب برنامه دارند، **پاستور از چندین منبع مختلف پشتیبانی می‌کند:**
**AUR Support** امکان نصب مستقیم بسته‌های AUR (Arch User Repository)، مشابه تجربه‌ی نسخه‌ی دسکتاپ آرچ لینوکس.
**Downgrade Support** امکان بازگشت به نسخه‌های قدیمی‌تر برنامه‌ها در صورت نیاز.
**F-Droid Support for Waydroid** پشتیبانی از مخزن F-Droid برای نصب برنامه‌های اندرویدی روی **Waydroid**.
**Flatpak Integration** اجرای نرم‌افزارهای Flatpak به‌صورت ایزوله و مستقل از سیستم.
**Sideloading** امکان نصب مستقیم بسته‌های نرم‌افزاری بدون نیاز به مخازن آنلاین.
**AppImage Support** پشتیبانی از فرمت **AppImage** برای اجرای برنامه‌ها بدون نیاز به نصب.
---
### **۲. ParchBootstrap ابزاری برای ساخت ایمیج‌های نصب‌پذیر**
یکی دیگر از ابزارهای اختصاصی پارچ موبایل، **ParchBootstrap** است. این ابزار به کاربران و توسعه‌دهندگان اجازه می‌دهد تا **ایمیج‌های سفارشی‌شده‌ی پارچ موبایل** را ایجاد کنند و آن را روی دستگاه‌های مختلف نصب کنند.
🔹 **ویژگی‌های ParchBootstrap:**
- **ساخت ایمیج‌های نصب‌پذیر از پارچ موبایل** برای استفاده در دستگاه‌های مختلف.
- **پورت کردن پارچ موبایل روی گوشی‌های جدید** با کمترین تغییرات ممکن.
- **ساخت نسخه‌های سفارشی** متناسب با نیاز کاربران.
ParchBootstrap این امکان را می‌دهد که **کاربران و توسعه‌دهندگان، نسخه‌ی مخصوص خود از پارچ موبایل را ایجاد کنند** و آن را روی دستگاه‌های مختلف تست و اجرا کنند.
## **وضعیت کنونی و برنامه‌های آینده**
پارچ موبایل هنوز در مرحله‌ی **توسعه‌ی فعال** قرار دارد. ابزارهای اصلی مورد نیاز برای اجرای این سیستم‌عامل روی موبایل در حال تکمیل شدن هستند و جامعه‌ی پارچ لینوکس در حال کار بر روی **بهینه‌سازی عملکرد، درایورها و پشتیبانی از سخت‌افزارهای بیشتر** است.
در آینده، تیم توسعه‌ی پارچ موبایل قصد دارد:
- **پشتیبانی از دستگاه‌های بیشتر** را اضافه کند.
- **محیط‌های کاربری مختلف** را برای استفاده روی موبایل بهینه‌سازی کند.
- **ابزارهای مدیریت سیستم موبایلی** را بهبود بخشد.
- **مستندات و راهنماهای پورت کردن سیستم به دستگاه‌های جدید** را منتشر کند.
## **چگونه می‌توانیم کمک کنیم؟**
پارچ موبایل یک پروژه‌ی **متن‌باز و جامعه‌محور** است. اگر شما یک **توسعه‌دهنده، تستر یا علاقه‌مند به لینوکس موبایلی** هستید، می‌توانید در توسعه‌ی این پروژه کمک کنید. برخی از راه‌های مشارکت:
- **تست و گزارش باگ‌ها**
- **کمک در توسعه و بهینه‌سازی کرنل و درایورها**
- **مستندسازی و نوشتن راهنما برای کاربران جدید**
- **ایجاد پورت‌های جدید برای دستگاه‌های دیگر**
برای پیوستن به پروژه، می‌توانید به **مخزن رسمی پارچ موبایل در گیت‌لب پارچ** یا کانال‌های ارتباطی جامعه‌ی پارچ لینوکس مراجعه کنید.

16
home.md Normal file
View file

@ -0,0 +1,16 @@
---
title: Home
description: Welcome to Parch Linux wiki!
published: true
date: 2024-04-05T10:17:27.414Z
tags: home, welcome
editor: markdown
dateCreated: 2024-04-05T10:17:16.712Z
---
# Welcome to Parch Linux wiki!
This is the official wiki for Parch Linux.
You can find **solution** for your problems as well as learning something new.

View file

@ -0,0 +1,32 @@
---
title: Ideas for Enterprise Edition
description: By Muhammadreza Haghiri
published: true
date: 2024-08-14T17:23:26.310Z
tags:
editor: markdown
dateCreated: 2024-08-14T17:23:15.665Z
---
# Ideas for Parch Enterprise
In this contribution, I, [Muhammadreza Haghiri](https://haghiri75.com/en) write my whole ideas about the project and its enterprise edition. As I mentioned to a private friendly chatroom, this will be my last contribution to Iranian FLOSS community.
I am not here to force Parch's team to do what I say, I'm here only to help and pay my 2 cents to this project which I think has potentials.
## Ideas
- __Name__ : Although the combination of _Persian_ and _Arch_ became Parch, but we should see the truth. The name and its Persian meaning (jug, pitcher, etc) became a matter of trolling and making fun of the project. In my personal and honest opinion, a new name can be a good start.
- __Freeze current project__: Current project, although it has thousands of users and downloads, is better to become dormant and only receive necessary updates. Do not make yourselves busy updating with a window manager no one - except the creator - is using! In short, do not waste time.
- __Forget about Enterprise Workstations__ : No one will leave those crappy Windows machines behind, focus on server.
## Ideas Specifically for Server
Just take a page from _Univention_'s book. This is a great project.
## More to think
- NAS
- Router
- ARM Based Kiosks
- Custom Operating System for customers and companies

104
neovim.md Normal file
View file

@ -0,0 +1,104 @@
---
title: Neovim as an IDE
description: Introduction to Vim and NeoVim, Along with How to Use NeoVim Like Popular IDEs
published: true
date: 2025-02-13T07:54:40.067Z
tags: ide, vim, neovim, nvim
editor: markdown
dateCreated: 2025-02-08T12:49:56.181Z
---
# Vim/NeoVim
## Introduction
**Vim** is a powerful open-source text editor that has been developed since the 1990s. Designed as a command-line editor, it offers highly customizable and personalizable features.
**NeoVim** is a more modern version inspired by Vim, featuring better internal APIs and improved window management, making it a powerful tool for developers.
## Installation
### 1. **Vim**
Vim is pre-installed on many Linux distributions such as Parch. To install the latest version, you can run the following command:
```bash
sudo pacman -S vim
```
### 2. **NeoVim**
NeoVim is a more modern editor that can be easily installed with the following command:
```bash
sudo pacman -S neovim
```
> Neovim is installed under the name `neovim` but it can be run using `nvim`.
---
## Turning NeoVim into an IDE
NeoVim alone does not have all the tools necessary for developers, so by using available plugins, it can be transformed into an environment similar to existing IDEs. There are two main approaches for this.
### 1. **Pre-configured Configurations**
For users who want to quickly set up a powerful development environment, using pre-configured setups is the best option. Some of the most popular configurations include:
#### **AstroNvim**
AstroNvim is a beautiful and feature-rich Neovim configuration focused on efficiency and extensibility. To install it, follow the [official AstroNvim documentation](https://docs.astronvim.com/).
#### **NVChad**
NVChad is a popular Neovim configuration that allows users to easily customize it. To install it, follow the [official NVChad documentation](https://nvchad.com/docs/quickstart/install).
### 2. **Installing from Scratch**
To turn NeoVim into an IDE, you can install the necessary plugins one by one. This approach is suitable for users who want full control over their settings. For this, you need a plugin manager to manage other plugins. One of the most popular plugin managers is [lazy.nvim](https://www.lazyvim.org/).
#### Installing the `lazy.nvim` Plugin Manager:
1. To install lazy.nvim, clone it using Git:
```bash
git clone https://github.com/LazyVim/starter ~/.config/nvim
```
2. After installation, remove the `.git` folder:
```bash
rm -rf ~/.config/nvim/.git
```
3. You can run it using the `nvim` command. now you need to install some plugins. Some of the most commonly used plugins include:
- **LSP**: `nvim-lspconfig`
- **Autocompletion**: `nvim-cmp`
- **Project Manager**: `project.nvim`
- **File Explorer**: `nvim-tree.lua`
#### Sample Configuration:
```lua
require("lazy").setup({
{
"folke/tokyonight.nvim", -- Theme
lazy = false,
priority = 1000,
config = function()
vim.cmd([[colorscheme tokyonight]])
end,
},
"neovim/nvim-lspconfig", -- LSP
"hrsh7th/nvim-cmp", -- Autocompletion
"nvim-tree/nvim-tree.lua", -- File explorer
"mbbill/undotree", -- Undo history
})
```
> For installation using this method, you can follow the [official lazy.nvim documentation](https://www.lazyvim.org/).
{.is-info}
## NeoVide
[NeoVide](https://neovide.dev/) is a GUI for NeoVim that functions like a regular terminal but adds more features to NeoVim.
#### Features
- **Ligatures**: Support for ligatures and font shaping to improve code appearance.
- **Animated Cursor**: Cursor animations make it easier to track the cursor's position.
- **Smooth Scrolling**: Instead of line-by-line scrolling, pixel-by-pixel animations smooth the user experience.
- **Blurred Floating Windows**: Floating windows have blurred backgrounds for better separation from the main screen.
- **Emoji Support**: Displays emojis even if the main font doesn't include them.
#### Installation:
```bash
sudo pacman -S neovide
```
## Plugin Marketplace
Most likely, all the IDEs you've worked with before have had an official marketplace for installing plugins, but NeoVim does not have an official marketplace. To find plugins, you can search online for each plugin or browse unofficial resources. Below are some community-made lists of NeoVim plugins:
- https://github.com/rockerBOO/awesome-neovim
- https://neovimcraft.com/
- https://vimawesome.com/

Binary file not shown.

After

Width:  |  Height:  |  Size: 101 KiB

58
phone-webcam.md Normal file
View file

@ -0,0 +1,58 @@
---
title: Using your android phone as a webcam
description:
published: true
date: 2024-07-29T18:39:45.995Z
tags: parch, parchlinux, scrcpy, webcam
editor: markdown
dateCreated: 2024-07-29T18:39:35.982Z
---
# How to use an android phone as a webcam in Parch Linux?
## Installing the dependencies
first of all you need to install some dependencies:
```bash
sudo pacman -S scrcpy dkms base-devel linux-headers v4l2loopback-dkms
```
then you need to load the module:
```bash
sudo modprobe v4l2loopback exclusive_caps=1
```
## Usage
### Camera Sharing
For using the front camera, first enable **usb debugging** in your phone, then connect your phone via cable and run this command in terminal:
```bash
scrcpy --video-source=camera --camera-size=1920x1080 --camera-facing=front --v4l2-sink=/dev/video0 --no-playback --no-window
```
For the back camera just change ```--camera-facing=front``` to ```--camera-facing=back``` .
#### testing camera
just open obs, or run this command:
```bash
ffplay /dev/video0
```
### mic sharing
For microphone you can run this command:
```bash
scrcpy --no-video --audio-source=mic --no-window
```
this would share your phone mic as system audio.

57
plasma.md Normal file
View file

@ -0,0 +1,57 @@
---
title: KDE Plasma
description:
published: true
date: 2024-10-17T09:39:53.561Z
tags: parchlinux, plasma, kde
editor: markdown
dateCreated: 2024-05-28T14:19:07.604Z
---
# KDE Plasma
## What is kde plasma?
KDE Plasma is a feature-rich and highly customizable desktop environment that offers a modern and intuitive user experience. It is known for its flexibility, extensive customization options, and a wide range of applications and tools.
Parch Linux Plasma is the **Flagship** version of Parch Linux.
![screenshot](https://raw.githubusercontent.com/parchlinux/parch-iso-plasma/main/image/screenshot.png)
## Installation
You can install Plasma by installing Parch Linux Plasma or changing your desktop.
For changing Desktop you need to install this packages:
```bash
sudo pacman -S plasma konsole kate dolphin sddm ark # for minimal installation
sudo pacman -S plasma konsole kate dolphin sddm ark plasmatube tokodon merkuro neochat marknote # for full ParchLinux plasma packages
```
>
> If you are migrating from latest version of gnome, remmeber to remove `QT_QPA_PLATFORMTHEME=qt6ct` from `/etc/envierment`
{.is-info}
## Tips and Tricks
### Taking a Regional screenshot
By pressing <kbd>meta</kbd> + <kbd>shift</kbd> + <kbd>print</kbd> spectacle would let you select a region of screen to take screenshot.
### Changing menu icon to ParchLinux logo
For now we don't apply the parchlogo to the application menu by default. for changing it right click on the menu and click on `Configure application menu` then selec parch-logo.svg from this location:
`/usr/share/pixmaps/parch-logo.svg`
### Firefox KDE file choser
For making firefox to work better with kde, either you can install `firefox-kde-opensuse`^AUR^ package or change the setting manually:
To use the KDE file picker in Firefox 64 or newer, install `xdg-desktop-portal` and `xdg-desktop-portal-kde`, then set `widget.use-xdg-desktop-portal.file-picker` to 1 in `about:config`

BIN
waydroid-checker1.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 229 KiB

BIN
waydroid-checker2.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 180 KiB

71
waydroid.md Normal file
View file

@ -0,0 +1,71 @@
---
title: Waydroid on Parch Linux
description: How to run android apps in Parch?
published: true
date: 2024-07-22T16:02:53.406Z
tags: parchlinux, android, waydroid, emulator
editor: markdown
dateCreated: 2024-07-22T15:57:03.046Z
---
# Waydroid
Waydroid is a container-based approach to boot a full Android system on a regular GNU/Linux system.
## Installation
In Parch Linux there is a script called ```waydroid-helper```^PPR^ which can be used to install waydroid with a non-gapps image (an android image without google apps such as play store ) on Parch Linux.
For start you need to install the Script from Parch Packages Repository:
```bash
sudo pacman -S waydroid-helper
```
### Checking system requirements
To check whether if your system is compatible with waydroid, you need to run ```waydroid-checker``` script.
```bash
waydroid-checker
```
After running it you will be prompted with this screen:
![waydroid-checker1.png](/waydroid-checker1.png)
Click on **Start Test** to begin.
![waydroid-checker2.png](/waydroid-checker2.png)
After the test is finished, **if your CPU passed you can continue with the installation**
### Installing Waydroid
you can run the ```waydroid-installer``` script to begin the installation:
```bash
waydroid-installer
```
### Post Installation
After the installation is finished you should init waydroid:
```bash
sudo waydroid init
```
after its done, if you are on **wayland** you can run waydroid from your application menu.
## X11
For running waydroid under **X11** You need to run ```waydroid-x11``` from terminal:
```bash
waydroid-x11
```
It would launch waydroid in your x11 session like XFCE, Mate etc... under weston.

46
xampp.md Normal file
View file

@ -0,0 +1,46 @@
---
title: XAMPP
description:
published: true
date: 2024-07-26T09:34:57.689Z
tags: xampp, apache, php
editor: markdown
dateCreated: 2024-07-26T09:34:43.803Z
---
# XAMPP
> XAMPP is an easy to install Apache distribution containing MariaDB, PHP, Perl and ProFTPD. It contains: Apache, MariaDB, PHP & PEAR, Perl, ProFTPD, phpMyAdmin, OpenSSL, GD, Freetype2, libjpeg, libpng, gdbm, zlib, expat, Sablotron, libxml, Ming, Webalizer, pdf class, ncurses, mod_perl, FreeTDS, gettext, mcrypt, mhash, eAccelerator, SQLite and IMAP C-Client.
## Installation
You can install XAMPP from aur using Paru in Parch Linux:
```bash
paru -S xampp
```
## Configuration
The default configuration should work out of the box. Setting the individual parts of XAMPP can by made by editing following files:
- ```/opt/lampp/etc/httpd.conf``` — Apache configuration. For example you can change folder with web page's source files.
- ```/opt/lampp/etc/php.ini``` — PHP configuration.
- ```/opt/lampp/phpmyadmin/config.inc.php``` — phpMyAdmin configuration.
- ```/opt/lampp/etc/proftpd.conf``` — ProFTPD configuration.
- ```/opt/lampp/etc/my.cnf``` — MySQL configuration.
If you would like to set up security of server, just run:
```bash
/opt/lampp/xampp security
```
## Usage
Use the following commands to control XAMPP:
```bash
/opt/lampp/xampp start,stop,restart
```
**Alternatively**, you can start, stop, or restart ```xampp.service```.

BIN
آبلیوین.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 61 KiB

BIN
نام‌بان.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 58 KiB

BIN
کاربراتور.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 67 KiB