document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-01-16 22:42:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'LCTT/master'

Browse Source
This commit is contained in:
Xingyu Wang 2019-10-04 10:15:52 +08:00
commit e33795a9a1
5 changed files with 725 additions and 520 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
sources/tech/20190214 The Earliest Linux Distros- Before Mainstream Distros Became So Popular.md
View File

@ -1,103 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (The Earliest Linux Distros: Before Mainstream Distros Became So Popular)
[#]: via: (https://itsfoss.com/earliest-linux-distros/)
[#]: author: (Avimanyu Bandyopadhyay https://itsfoss.com/author/avimanyu/)
The Earliest Linux Distros: Before Mainstream Distros Became So Popular
======
In this throwback history article, we’ve tried to look back into how some of the earliest Linux distributions evolved and came into being as we know them today.
![][1]
In here we have tried to explore how the idea of popular distros such as Red Hat, Debian, Slackware, SUSE, Ubuntu and many others came into being after the first Linux kernel became available.
As Linux was initially released in the form of a kernel in 1991, the distros we know today was made possible with the help of numerous collaborators throughout the world with the creation of shells, libraries, compilers and related packages to make it a complete Operating System.
### 1\. The first known “distro” by HJ Lu
The way we know Linux distributions today goes back to 1992, when the first known distro-like tools to get access to Linux were released by HJ Lu. It consisted of two 5.25” floppy diskettes:
![Linux 0.12 Boot and Root Disks | Photo Credit][2]
* **LINUX 0.12 BOOT DISK** : The “boot” disk was used to boot the system first.
* **LINUX 0.12 ROOT DISK** : The second “root” disk for getting a command prompt for access to the Linux file system after booting.
To install 0.12 on a hard drive, one had to use a hex editor to edit its master boot record (MBR) and that was quite a complex process, especially during that era.
Feeling too nostalgic?
You can [install cool-retro-term application][3] that gives you a Linux terminal in the vintage looks of the 90’s computers.
### 2\. MCC Interim Linux
![MCC Linux 0.99.14, 1993 | Image Credit][4]
Initially released in the same year as “LINUX 0.12” by Owen Le Blanc of Manchester Computing Centre in England, MCC Interim Linux was the first Linux distribution for novice users with a menu driven installer and end user/programming tools. Also in the form of a collection of diskettes, it could be installed on a system to provide a basic text-based environment.
MCC Interim Linux was much more user-friendly than 0.12 and the installation process on a hard drive was much easier and similar to modern ways. It did not require using a hex editor to edit the MBR.
Though it was first released in February 1992, it was also available for download through FTP since November that year.
### 3\. TAMU Linux
![TAMU Linux | Image Credit][5]
TAMU Linux was developed by Aggies at Texas A&M with the Texas A&M Unix & Linux Users Group in May 1992 and was called TAMU 1.0A. It was the first Linux distribution to offer the X Window System instead of just a text based operating system.
### 4\. Softlanding Linux System (SLS)
![SLS Linux 1.05, 1994 | Image Credit][6]
“Gentle Touchdowns for DOS Bailouts” was their slogan! SLS was released by Peter McDonald in May 1992. SLS was quite widely used and popular during its time and greatly promoted the idea of Linux. But due to a decision by the developers to change the executable format in the distro, users stopped using it.
Many of the popular distros the present community is most familiar with, evolved via SLS. Two of them are:
* **Slackware** : One of the earliest Linux distros, Slackware was created by Patrick Volkerding in 1993. Slackware is based on SLS and was one of the very first Linux distributions.
* **Debian** : An initiative by Ian Murdock, Debian was also released in 1993 after moving on from the SLS model. The very popular Ubuntu distro we know today is based on Debian.
### 5\. Yggdrasil
![LGX Yggdrasil Fall 1993 | Image Credit][7]
Released on December 1992, Yggdrasil was the first distro to give birth to the idea of Live Linux CDs. It was developed by Yggdrasil Computing, Inc., founded by Adam J. Richter in Berkeley, California. It could automatically configure itself on system hardware as “Plug-and-Play”, which is a very regular and known feature in today’s time. The later versions of Yggdrasil included a hack for running any proprietary MS-DOS CD-ROM driver within Linux.
![Yggdrasil’s Plug-and-Play Promo | Image Credit][8]
Their motto was “Free Software For The Rest of Us”.
In the late 90s, one very popular distro was [Mandriva][9], first released in 1998, by unifying the French _Mandrake Linux_ distribution with the Brazilian _Conectiva Linux_ distribution. It had a release lifetime of 18 months for updates related to Linux and system software and desktop based updates were released every year. It also had server versions with 5 years of support. Now we have [Open Mandriva][10].
If you have more nostalgic distros to share from the earliest days of Linux release, please share with us in the comments below.
--------------------------------------------------------------------------------
via: https://itsfoss.com/earliest-linux-distros/
作者：[Avimanyu Bandyopadhyay][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/avimanyu/
[b]: https://github.com/lujun9972
[1]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/earliest-linux-distros.png?resize=800%2C450&ssl=1
[2]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/Linux-0.12-Floppies.jpg?ssl=1
[3]: https://itsfoss.com/cool-retro-term/
[4]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/01/MCC-Interim-Linux-0.99.14-1993.jpg?fit=800%2C600&ssl=1
[5]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/TAMU-Linux.jpg?ssl=1
[6]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/01/SLS-1.05-1994.jpg?ssl=1
[7]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/LGX_Yggdrasil_CD_Fall_1993.jpg?fit=781%2C800&ssl=1
[8]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/Yggdrasil-Linux-Summer-1994.jpg?ssl=1
[9]: https://en.wikipedia.org/wiki/Mandriva_Linux
[10]: https://www.openmandriva.org/

417
sources/tech/20190916 Linux commands to display your hardware information.md
View File

@ -1,417 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (way-ww)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Linux commands to display your hardware information)
[#]: via: (https://opensource.com/article/19/9/linux-commands-hardware-information)
[#]: author: (Howard Fosdick https://opensource.com/users/howtechhttps://opensource.com/users/sethhttps://opensource.com/users/sethhttps://opensource.com/users/seth)
Linux commands to display your hardware information
======
Get the details on what's inside your computer from the command line.
![computer screen ][1]
There are many reasons you might need to find out details about your computer hardware. For example, if you need help fixing something and post a plea in an online forum, people will immediately ask you for specifics about your computer. Or, if you want to upgrade your computer, you'll need to know what you have and what you can have. You need to interrogate your computer to discover its specifications.
The easiest way is to do that is with one of the standard Linux GUI programs:
* [i-nex][2] collects hardware information and displays it in a manner similar to the popular [CPU-Z][3] under Windows.
* [HardInfo][4] displays hardware specifics and even includes a set of eight popular benchmark programs you can run to gauge your system's performance.
* [KInfoCenter][5] and [Lshw][6] also display hardware details and are available in many software repositories.
Alternatively, you could open up the box and read the labels on the disks, memory, and other devices. Or you could enter the boot-time panels—the so-called UEFI or BIOS panels. Just hit [the proper program function key][7] during the boot process to access them. These two methods give you hardware details but omit software information.
Or, you could issue a Linux line command. Wait a minute… that sounds difficult. Why would you do this?
Sometimes it's easy to find a specific bit of information through a well-targeted line command. Perhaps you don't have a GUI program available or don't want to install one.
Probably the main reason to use line commands is for writing scripts. Whether you employ the Linux shell or another programming language, scripting typically requires coding line commands.
Many line commands for detecting hardware must be issued under root authority. So either switch to the root user ID, or issue the command under your regular user ID preceded by **sudo**:
```
`sudo <the_line_command>`
```
and respond to the prompt for the root password.
This article introduces many of the most useful line commands for system discovery. The quick reference chart at the end summarizes them.
### Hardware overview
There are several line commands that will give you a comprehensive overview of your computer's hardware.
The **inxi** command lists details about your system, CPU, graphics, audio, networking, drives, partitions, sensors, and more. Forum participants often ask for its output when they're trying to help others solve problems. It's a standard diagnostic for problem-solving:
```
`inxi -Fxz`
```
The **-F** flag means you'll get full output, **x** adds details, and **z** masks out personally identifying information like MAC and IP addresses.
The **hwinfo** and **lshw** commands display much of the same information in different formats:
```
`hwinfo --short`
```
or
```
`lshw -short`
```
The long forms of these two commands spew out exhaustive—but hard to read—output:
```
`hwinfo`
```
or
```
`lshw`
```
### CPU details
You can learn everything about your CPU through line commands. View CPU details by issuing either the **lscpu** command or its close relative **lshw**:
```
`lscpu`
```
or
```
`lshw -C cpu`
```
In both cases, the last few lines of output list all the CPU's capabilities. Here you can find out whether your processor supports specific features.
With all these commands, you can reduce verbiage and narrow any answer down to a single detail by parsing the command output with the **grep** command. For example, to view only the CPU make and model:
```
`lshw -C cpu | grep -i product`
```
To view just the CPU's speed in megahertz:
```
`lscpu | grep -i mhz`
```
or its [BogoMips][8] power rating:
```
`lscpu | grep -i bogo`
```
The **-i** flag on the **grep** command simply ensures your search ignores whether the output it searches is upper or lower case.
### Memory
Linux line commands enable you to gather all possible details about your computer's memory. You can even determine whether you can add extra memory to the computer without opening up the box.
To list each memory stick and its capacity, issue the **dmidecode** command:
```
`dmidecode -t memory | grep -i size`
```
For more specifics on system memory, including type, size, speed, and voltage of each RAM stick, try:
```
`lshw -short -C memory`
```
One thing you'll surely want to know is is the maximum memory you can install on your computer:
```
`dmidecode -t memory | grep -i max`
```
Now find out whether there are any open slots to insert additional memory sticks. You can do this without opening your computer by issuing this command:
```
`lshw -short -C memory | grep -i empty`
```
A null response means all the memory slots are already in use.
Determining how much video memory you have requires a pair of commands. First, list all devices with the **lspci** command and limit the output displayed to the video device you're interested in:
```
`lspci | grep -i vga`
```
The output line that identifies the video controller will typically look something like this:
```
`00:02.0 VGA compatible controller: Intel Corporation 82Q35 Express Integrated Graphics Controller (rev 02)`
```
Now reissue the **lspci** command, referencing the video device number as the selected device:
```
`lspci -v -s 00:02.0`
```
The output line identified as _prefetchable_ is the amount of video RAM on your system:
```
...
Memory at f0100000 (32-bit, non-prefetchable) [size=512K]
I/O ports at 1230 [size=8]
Memory at e0000000 (32-bit, prefetchable) [size=256M]
Memory at f0000000 (32-bit, non-prefetchable) [size=1M]
...
```
Finally, to show current memory use in megabytes, issue:
```
`free -m`
```
This tells how much memory is free, how much is in use, the size of the swap area, and whether it's being used. For example, the output might look like this:
```
              total        used        free     shared    buff/cache   available
Mem:          11891        1326        8877      212        1687       10077
Swap:          1999           0        1999
```
The **top** command gives you more detail on memory use. It shows current overall memory and CPU use and also breaks it down by process ID, user ID, and the commands being run. It displays full-screen text output:
```
`top`
```
### Disks, filesystems, and devices
You can easily determine whatever you wish to know about disks, partitions, filesystems, and other devices.
To display a single line describing each disk device:
```
`lshw -short -C disk`
```
Get details on any specific SATA disk, such as its model and serial numbers, supported modes, sector count, and more with:
```
`hdparm -i /dev/sda`
```
Of course, you should replace **sda** with **sdb** or another device mnemonic if necessary.
To list all disks with all their defined partitions, along with the size of each, issue:
```
`lsblk`
```
For more detail, including the number of sectors, size, filesystem ID and type, and partition starting and ending sectors:
```
`fdisk -l`
```
To start up Linux, you need to identify mountable partitions to the [GRUB][9] bootloader. You can find this information with the **blkid** command. It lists each partition's unique identifier (UUID) and its filesystem type (e.g., ext3 or ext4):
```
`blkid`
```
To list the mounted filesystems, their mount points, and the space used and available for each (in megabytes):
```
`df -m`
```
Finally, you can list details for all USB and PCI buses and devices with these commands:
```
`lsusb`
```
or
```
`lspci`
```
### Network
Linux offers tons of networking line commands. Here are just a few.
To see hardware details about your network card, issue:
```
`lshw -C network`
```
Traditionally, the command to show network interfaces was **ifconfig**:
```
`ifconfig -a`
```
But many people now use:
```
`ip link show`
```
or
```
`netstat -i`
```
In reading the output, it helps to know common network abbreviations:
**Abbreviation** | **Meaning**
---|---
**lo** | Loopback interface
**eth0** or **enp*** | Ethernet interface
**wlan0** | Wireless interface
**ppp0** | Point-to-Point Protocol interface (used by a dial-up modem, PPTP VPN connection, or USB modem)
**vboxnet0** or **vmnet*** | Virtual machine interface
The asterisks in this table are wildcard characters, serving as a placeholder for whatever series of characters appear from system to system. ****
To show your default gateway and routing tables, issue either of these commands:
```
`ip route | column -t`
```
or
```
`netstat -r`
```
### Software
Let's conclude with two commands that display low-level software details. For example, what if you want to know whether you have the latest firmware installed? This command shows the UEFI or BIOS date and version:
```
`dmidecode -t bios`
```
What is the kernel version, and is it 64-bit? And what is the network hostname? To find out, issue:
```
`uname -a`
```
### Quick reference chart
This chart summarizes all the commands covered in this article:
Display info about all hardware | **inxi -Fxz**              _\--or--_
**hwinfo --short**     _\--or--_
**lshw  -short**
---|---
Display all CPU info | **lscpu**                  _\--or--_
**lshw -C cpu**
Show CPU features (e.g., PAE, SSE2) | **lshw -C cpu | grep -i capabilities**
Report whether the CPU is 32- or 64-bit | **lshw -C cpu | grep -i width**
Show current memory size and configuration | **dmidecode -t memory | grep -i size**    _\--or--_
**lshw -short -C memory**
Show maximum memory for the hardware | **dmidecode -t memory | grep -i max**
Determine whether memory slots are available | **lshw -short -C memory | grep -i empty**
(a null answer means no slots available)
Determine the amount of video memory | **lspci | grep -i vga**
then reissue with the device number;
for example:  **lspci -v -s 00:02.0**
The VRAM is the _prefetchable_ value.
Show current memory use | **free -m**    _\--or--_
**top**
List the disk drives | **lshw -short -C disk**
Show detailed information about a specific disk drive | **hdparm -i /dev/sda**
(replace **sda** if necessary)
List information about disks and partitions | **lsblk **     (simple)      _\--or--_
**fdisk -l**   (detailed)
List partition IDs (UUIDs) | **blkid**
List mounted filesystems, their mount points,
and megabytes used and available for each | **df -m**
List USB devices | **lsusb**
List PCI devices | **lspci**
Show network card details | **lshw -C network**
Show network interfaces | **ifconfig -a**       _\--or--_
**ip link show   **_\--or--_
**netstat -i**
Display routing tables | **ip route | column -t`  `**_\--or--_
**netstat -r**
Display UEFI/BIOS info | **dmidecode -t bios**
Show kernel version, network hostname, more | **uname -a**
Do you have a favorite command that I overlooked? Please add a comment and share it.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/9/linux-commands-hardware-information
作者：[Howard Fosdick][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/howtechhttps://opensource.com/users/sethhttps://opensource.com/users/sethhttps://opensource.com/users/seth
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/features_solutions_command_data.png?itok=4_VQN3RK (computer screen )
[2]: http://sourceforge.net/projects/i-nex/
[3]: https://www.cpuid.com/softwares/cpu-z.html
[4]: http://sourceforge.net/projects/hardinfo.berlios/
[5]: https://userbase.kde.org/KInfoCenter
[6]: http://www.binarytides.com/linux-lshw-command/
[7]: http://www.disk-image.com/faq-bootmenu.htm
[8]: https://en.wikipedia.org/wiki/BogoMips
[9]: https://www.dedoimedo.com/computers/grub.html

225
sources/tech/20191001 How to create the data structure for a Corteza Low Code application.md Normal file
View File

@ -0,0 +1,225 @@
[#]: collector: (lujun9972)
[#]: translator: ( )
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (How to create the data structure for a Corteza Low Code application)
[#]: via: (https://opensource.com/article/19/10/corteza-low-code-data-structure)
[#]: author: (Lenny Horstink https://opensource.com/users/lenny-horstink)
How to create the data structure for a Corteza Low Code application
======
Corteza is an open source alternative to Salesforce. Learn how to use it
in this series.
![Green graph of measurements][1]
In the [first article][2] in this series, I showed how to create a custom application to track donations using Corteza Low-Code, a graphical user interface- (GUI) and web-based development environment that serves as an alternative to Salesforce. So far, the Donations application merely exists, but this article explains how to make it do something by populating it with a data structure using modules and fields.
Modules and fields exist inside your application. (In programming terminology, they are "locally defined.") Modules and fields define places where data is stored in your application. Without modules and fields, your application has no memory nor anything to work with, so defining them is the next step when creating a new app.
The [Donations application][3] is available on the Corteza community server. You need to be logged in or create a free Corteza community server account to check it out.
### Enter the application's admin area
To enter the admin area of an application, you first need to open the application inside Corteza Low-Code. To enter the Donations application created in the first part of this series:
1. Enter Corteza. (Read [_Intro to Corteza, an open source alternative to Salesforce_][4] if you need some background on this.)
2. Click on the **+** button to create a new tab.
3. Select Corteza Low-Code.
4. Click on the Donations namespace to enter the Donations application.
Since the Donations application doesn't have any modules or pages yet, the only thing you see is an **Admin panel** link on the right. If the applications had pages, it would show the main menu and the **Admin panel** link on the far right.
![Open Corteza Low Code admin panel][5]
Click on it to enter the application's admin area. There are four menu items:
![Corteza Low Code admin panel menu][6]
* **Modules:** Create or edit modules and fields
* **Pages:** Define the visual part of your application
* **Charts:** Create charts to add to pages
* **Automation:** Add automation rules to automate business processes and workflows
The **Public pages** link takes you back to your application.
### Create modules and fields
Modules and fields define what data you need to store in your application and how that data links to other data. If you've ever built a database with [LibreOffice Base][7], Filemaker Pro, or a similar application, this might feel familiar—but you don't need any database experience to work with Corteza.
#### Modules
A module is like a table in a database. A simple application typically has a few modules, while bigger applications have many more. Corteza CRM, for example, has over 35. The number of modules an application can have is unlimited.
A new application does not have any modules. You can create one by using the form on top or by importing an existing module from a different application using an export file. You can import and export individual modules or all modules at the same time.
When you create a module, best practice is to give it a descriptive name without spaces and using capital letters on different words, e.g., _Lead_, _Account_, or _CaseUpdate_.
The Donations application includes the following modules:
* **Contact:** To store the donor's contact data
* **ContactDonation:** To track a contact's donation(s)
* **Project:** To store a project you can assign donations to
* **Note:** To store notes related to a project
![Donations application modules][8]
#### Fields
Each module consists of a set of fields that define what data you want to store and in what format.
You can add new fields to a module by using the **Add new field** button. This adds a new row with the following fields:
* **Name:** It must be unique and cannot have spaces, e.g., "firstname." This is not shown to the end user.
* **Title:** This is the field's label—the field name the end users see when they view or edit a record. It can contain any character, including spaces. Although it's best practice to keep this title unique, it's not mandatory. An example is "First name."
* **Type:** This is where you set the field type. The wrench icon on the right allows you to set more detailed data for the field type.
* **Multiple values:** This checkbox is available when you want a field type to allow multiple value entries.
* **Required:** This makes the field mandatory for the end user when creating or editing a record.
* **Sensitive:** This allows you to mark data that is sensitive, such as name, email, or telephone number, so your application is compliant with privacy regulations such as the [GDPR][9].
At the end of the row, you can find a **Delete** button (to remove a field) and a **Permission** button (to set read permissions and update field permissions per role).
### Field types
You can select from the following field types. The wrench icon beside the field type provides further options for each case.
* **Checkbox (Y/N):** This field shows a checkbox to the end user when editing a record. When you click on the wrench icon, you can select what checked and unchecked represent. For example: Yes/No, Active/Inactive, etc.
* **DateTime:** This makes a date field. You can select:
* Date only
* Time only
* Past values only
* Future value only
* Output relative value (e.g., three days ago)
* Custom output format (see [Moment.js][10] for formatting options)
* **Email:** This field auto-validates whether the input is an email and turns it into a clickable email link in record-viewing mode. You can select the **Don't turn email into a link** option to remove the auto-link feature.
* **Select:** When you click on the wrench icon, you can use the **Add** button to add as many Select options as you need. You can also set whether the end user can select multiple values at once.
* **Number:** This field gives you the option to add a prefix (for example a $ for values in dollars), a suffix (for example % for a number that represents a percentage), and the decimal precision (e.g., zero for whole numbers or two for values like 1.13, 2.44, 3.98), and you can use the **Format Input** field to create more complex formats.
* **Record:** This field allows you to link the current module to another module. It will show as a Select to the end user. You can select the module in the **Module name** field and choose the field to use to load the Select options. In **Query fields on search**, you can define what fields you want the user to be able to search on. As with the **Select** field type, you can set whether the user can select multiple values at once.
* **String:** By default, a String field is a single-line text-input field, but you can choose to make it multi-line or even a rich text editor.
* **URL:** The URL field automatically validates whether the field is a link to a site. You can select the following options for this field:
* Trim # from the URL
* Trim ? from the URL
* Only allow SSL (HTTPS) URLs
* Don't turn URL into a link
* **User:** This creates a Select field that loads with all users in Corteza. You can preset the value to the current user.
* **File:** This creates a **File Upload** button for the end user.
#### Field types in the Donations application
The Donations application includes the following fields in its four modules.
##### 1\. Contact
![Contact module][11]
* Name (String)
* Email (Email)
* Phone (String)
* Address (String; _Multi-line_)
##### 2\. ContactDonation
![Corteza Donations app modules][12]
* Contact (Record; link to **Contact**)
* Donation (Number; _Prefix $_ and _Precision 2_)
* Project (Record; link to **Project**)
##### 3\. Project
![Project module][13]
* Name (String)
* Description (String; _Multi-line_ and _Use rich text editor_)
* Status (Select; with options _Planning_, _Active_, and _Finished_)
* Start date (DateTime; _Date only_)
* Website link (URL)
* Donations total (Number; _Prefix $_ and _Precision 2_)
* Project owner (User; _Multiple select_ and _Preset with current user_)
##### 4\. Notes
![Notes module][14]
* Project (Record; link to **Project**)
* Subject (String)
* Note (String; _Multi-line_ and _Use rich text editor_)
* File (File; _Single image_)
### Create relationships between modules
Practically every Corteza Low Code application consists of multiple modules that are linked together. For example, projects can have notes or donations can be assigned to different projects. The **Record** field type creates relationships between modules.
The **Record** field type's basic function is to link from module B back to module A. Records in module B are children of records in module A (you could say it's a 1-N relationship).
For example, in the Donations application, the module **Note** has a **Record** field that links to the module **Project**. The end user will see a **Select** field in a **Note** record with the value of the **Project** that the note pertains to.
To create this relationship in the Donations application, select the wrench icon in the **projectId** row:
![Wrench icon][15]
In the popup that opens, select the module the field will link to, the label end users will see, and which fields the end user can search on. 
![Setting query fields for search][16]
This creates a simple relationship that allows the **Project** to have **Notes**. A many-to-many relationship between modules is more complex. For example, the Donations application needs to support contacts who make multiple donations and donations that are assigned to different projects. The **ContactDonation** module sits in the middle to manage this.
This module has two fields of the **Record** type. For each, we need to select the correct module and set the label and query fields the user can search on. The Donations application needs the following to be set for the **Contact** and **Project** modules:
![Contact module field settings][17]
![Project module field settings][18]
This creates a many-to-many relationship between modules.
You've now set up a structure for the data in your application. The next step is to create the visual side of your app using Corteza's **Pages** feature. It's easier than you might expect, as you'll see in the third article in this series.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/10/corteza-low-code-data-structure
作者：[Lenny Horstink][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/lenny-horstink
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/metrics_lead-steps-measure.png?itok=DG7rFZPk (Green graph of measurements)
[2]: https://opensource.com/article/19/9/how-build-application-corteza-low-code-open-source-alternative-salesforce
[3]: https://latest.cortezaproject.org/compose/ns/donations/
[4]: https://opensource.com/article/19/8/corteza-open-source-alternative-salesforce
[5]: https://opensource.com/sites/default/files/uploads/corteza_donationsadminpanel.png (Open Corteza Low Code admin panel)
[6]: https://opensource.com/sites/default/files/uploads/corteza_donationsmenuadminpanel.png (Corteza Low Code admin panel menu)
[7]: https://www.libreoffice.org/discover/base/
[8]: https://opensource.com/sites/default/files/uploads/corteza_donationstmodules.png (Donations application modules)
[9]: https://eugdpr.org/
[10]: https://momentjs.com/docs/#/displaying/format/
[11]: https://opensource.com/sites/default/files/uploads/corteza_contactmodulefields.png (Contact module)
[12]: https://opensource.com/sites/default/files/uploads/corteza_contactdonationmodule.png (Corteza Donations app modules)
[13]: https://opensource.com/sites/default/files/uploads/corteza_projectmodule.png (Project module)
[14]: https://opensource.com/sites/default/files/uploads/corteza_notesmodule.png (Notes module)
[15]: https://opensource.com/sites/default/files/uploads/corteza_createrelationshipicon.png (Wrench icon)
[16]: https://opensource.com/sites/default/files/uploads/corteza_queryfieldsonsearch.png (Setting query fields for search)
[17]: https://opensource.com/sites/default/files/uploads/corteza_modulefieldsettings-contact.png (Contact module field settings)
[18]: https://opensource.com/sites/default/files/uploads/corteza_modulefieldsettings-project.png (Project module field settings)

101
translated/tech/20190214 The Earliest Linux Distros- Before Mainstream Distros Became So Popular.md Normal file
View File

@ -0,0 +1,101 @@
[#]: collector: (lujun9972)
[#]: translator: (wxy)
[#]: reviewer: (wxy)
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (The Earliest Linux Distros: Before Mainstream Distros Became So Popular)
[#]: via: (https://itsfoss.com/earliest-linux-distros/)
[#]: author: (Avimanyu Bandyopadhyay https://itsfoss.com/author/avimanyu/)
主流发行版之前的那些最早的 Linux 发行版
======
> 在这篇回溯历史的文章中，我们尝试回顾一些最早的 Linux 发行版是如何演变的，并形成我们今天所知道的发行版的。
![][1]
在这里，我们尝试探讨了第一个 Linux 内核问世后，诸如 Red Hat、Debian、Slackware、SUSE、Ubuntu 等诸多流行的发行版的想法是如何产生的。
随着 1991 年 Linux 最初以内核的形式发布，今天我们所知道的发行版在世界各地众多合作者的帮助下得以创建 shell、库、编译器和相关软件包，从而使其成为一个完整的操作系统。
### 1、第一个已知的“发行版”是由 HJ Lu 创建的
Linux 发行版这种方式可以追溯到 1992 年，当时可以用来访问 Linux 的第一个已知的类似发行版的工具是由 HJ Lu 发布的。它由两个 5.25 英寸软盘组成：
![Linux 0.12 Boot and Root Disks | Photo Credit][2]
* LINUX 0.12 BOOT DISK：“启动”磁盘用来先启动系统。
* LINUX 0.12 ROOT DISK：第二个“根”磁盘，用于在启动后获取命令提示符以访问 Linux 文件系统。
要在硬盘上安装 LINUX 0.12，必须使用十六进制编辑器来编辑其主启动记录（MBR），这是一个非常复杂的过程，尤其是在那个时代。
> 感觉太怀旧了？
>
> 你可以[安装 cool-retro-term 应用程序][3]，它可以为你提供 90 年代计算机的复古外观的 Linux 终端。
### 2、MCC Interim Linux
![MCC Linux 0.99.14, 1993 | Image Credit][4]
MCC Interim Linux 最初由英格兰曼彻斯特计算中心的 Owen Le Blanc 与 “LINUX 0.12” 同年发布，它是针对普通用户的第一个 Linux 发行版，它具有菜单驱动的安装程序和最终用户/编程工具。它也是以软盘集的形式，可以将其安装在系统上以提供基于文本的基本环境。
MCC Interim Linux 比 0.12 更加易于使用，并且在硬盘驱动器上的安装过程更加轻松和类似于现代方式。它不需要使用十六进制编辑器来编辑 MBR。
尽管它于 1992 年 2 月首次发布，但自当年 11 月以来也可以通过 FTP 下载。
### 3、TAMU Linux
![TAMU Linux | Image Credit][5]
TAMU Linux 由 Texas A＆M 的 Aggies 与 Texas A＆M Unix ＆ Linux 用户组于 1992 年 5 月开发，被称为 TAMU 1.0A。它是第一个提供 X Window System 的 Linux 发行版，而不仅仅是基于文本的操作系统。
### 4、Softlanding Linux System (SLS)
![SLS Linux 1.05, 1994 | Image Credit][6]
他们的口号是“DOS 伞降的温柔救援”！SLS 由 Peter McDonald 于 1992 年 5 月发布。SLS 在其时代得到了广泛的使用和流行，并极大地推广了 Linux 的思想。但是由于开发人员决定更改发行版中的可执行格式，因此用户停止使用它。
当今社区最熟悉的许多流行发行版是通过 SLS 演变而成的。其中两个是：
* Slackware：它是最早的 Linux 发行版之一，由 Patrick Volkerding 于 1993 年创建。Slackware 基于 SLS，是最早的 Linux 发行版之一。
* Debian：由 Ian Murdock 发起，Debian 在从 SLS 模型继续发展之后于 1993 年发布。我们今天知道的非常流行的 Ubuntu 发行版基于 Debian。
### 5、Yggdrasil
![LGX Yggdrasil Fall 1993 | Image Credit][7]
Yggdrasil 于 1992 年 12 月发行，是第一个产生 Live Linux CD 想法的发行版。它是由 Yggdrasil 计算公司开发的，该公司由位于加利福尼亚州伯克利的 Adam J. Richter 创立。它可以在系统硬件上自动配置自身，即“即插即用”功能，这是当今非常普遍且众所周知的功能。Yggdrasil 后来的版本包括一个用于在 Linux 中运行任何专有 MS-DOS CD-ROM 驱动程序的黑科技。
![Yggdrasil’s Plug-and-Play Promo | Image Credit][8]
他们的座右铭是“我们其余人的免费软件”。
### 6、Mandriva
在 90 年代后期，有一个非常受欢迎的发行版 [Mandriva][9]，该发行版于 1998 年首次发行，是通过将法国的 Mandrake Linux 发行版与巴西的 Conectiva Linux 发行版统一起来形成的。它的发布寿命为 18 个月，会对 Linux 和系统软件进行更新，并且每年都会发布基于桌面的更新。它还有带有 5 年支持的服务器版本。现在是 [Open Mandriva][10]。
如果你在 Linux 发行之初就用过更多的怀旧发行版，请在下面的评论中与我们分享。
--------------------------------------------------------------------------------
via: https://itsfoss.com/earliest-linux-distros/
作者：[Avimanyu Bandyopadhyay][a]
选题：[lujun9972][b]
译者：[wxy](https://github.com/wxy)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/avimanyu/
[b]: https://github.com/lujun9972
[1]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/02/earliest-linux-distros.png?resize=800%2C450&ssl=1
[2]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/Linux-0.12-Floppies.jpg?ssl=1
[3]: https://itsfoss.com/cool-retro-term/
[4]: https://i2.wp.com/itsfoss.com/wp-content/uploads/2019/01/MCC-Interim-Linux-0.99.14-1993.jpg?fit=800%2C600&ssl=1
[5]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/TAMU-Linux.jpg?ssl=1
[6]: https://i1.wp.com/itsfoss.com/wp-content/uploads/2019/01/SLS-1.05-1994.jpg?ssl=1
[7]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/LGX_Yggdrasil_CD_Fall_1993.jpg?fit=781%2C800&ssl=1
[8]: https://i0.wp.com/itsfoss.com/wp-content/uploads/2019/01/Yggdrasil-Linux-Summer-1994.jpg?ssl=1
[9]: https://en.wikipedia.org/wiki/Mandriva_Linux
[10]: https://www.openmandriva.org/

399
translated/tech/20190916 Linux commands to display your hardware information.md Normal file
View File

@ -0,0 +1,399 @@
[#]: collector: (lujun9972)
[#]: translator: (way-ww)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (Linux commands to display your hardware information)
[#]: via: (https://opensource.com/article/19/9/linux-commands-hardware-information)
[#]: author: (Howard Fosdick https://opensource.com/users/howtechhttps://opensource.com/users/sethhttps://opensource.com/users/sethhttps://opensource.com/users/seth)
Linux 命令行显示硬件信息
======
通过命令行获取电脑硬件详细信息
![computer screen ][1]
你可能会有很多的原因需要查清计算机硬件的详细信息。 例如， 你需要修复某些问题并在论坛上发出请求， 人们可能会立即询问你的计算机具体的信息。 或者当你想要升级计算机配置时， 你需要知道现有的硬件型号和能够升级的型号。 这些都需要查询你的计算机具体规格信息。
最简单的方法是使用标准的 Linux GUI 程序之一:
* [i-nex][2] 收集硬件信息并且像 Windows 下流行的 [CPU-Z][3] 方式显示。
* [HardInfo][4] 显示硬件具体信息甚至包括一组八个的流行的基础程序你可以用它们评估你的系统性能。
* [KInfoCenter][5] 和 [Lshw][6] 也能够显示硬件的详细信息并且可以从许多软件仓库中获取。
或者， 你也可以拆开电脑外盒去阅读硬盘， 内存和其他设备上的标签信息。 或者你可以在系统启动时， 按下相应的按键进入 UEFI 和 BIOS 界面获得信息。 这俩种方式都会向你显示硬件信息但省略软件信息。
你也可以使用命令行获取硬件信息。 等一下… 这听起来有些困难。 为什么你会要这样做？
有时候通过使用一条针对性强的命令可以很轻松的找到特定信息。 也可能你没有可用的 GUI 程序或者只是不想安装这样的程序。
使用命令行的主要原因可能是编写脚本。 无论你是使用 Linux shell 还是其他编程语言来编写脚本通常都需要使用命令行。
很多检测硬件信息的命令行都需要使用 root 权限。 所以要么切换到 root 用户， 要么使用 **sudo** 在普通用户状态下发出命令:
```
sudo <the_line_command>
```
并按提示输入密码。
这篇文章介绍了很多有用的系统发现命令。 文章最后的快速查询表对它们作出了总结。
### 硬件概述
下面几条命令可以全面概述计算机硬件信息。
**inxi** 命令能够列出包括 CPU， 图形， 音频， 网络， 驱动， 分区， 传感器等详细信息。 当论坛里的人尝试帮助其他人解决问题的时候， 他们常常询问此命令的输出。 这是解决问题的标准诊断程序:
```
inxi -Fxz
```
**-F** 参数意味着你将得到完整的输出， **x** 增加细节信息， **z** 参数隐藏像 MAC 和 IP 等私人身份信息。
**hwinfo** 和 **lshw** 命令以不同的格式显示大量相同的信息:
```
hwinfo --short
```
或
```
lshw -short
```
这俩条命令的长格式输出非常详细但也有点难以阅读:
```
hwinfo
```
或
```
lshw
```
### CPU 详细信息
通过命令你可以了解关于你的 CPU 的任何信息。 使用 **lscpu** 命令或与它相近的 **lshw** 命令查看 CPU 的详细信息:
```
lscpu
```
或
```
lshw -C cpu
```
在这俩个例子中， 输出的最后几行都列出了所有 CPU 的功能。 你可以查看你的处理器是否支持特定的功能。
使用这些命令的时候， 你可以通过使用 **grep** 命令过滤复杂的信息， 并缩小所需信息范围。 例如， 只查看 CPU 品牌和型号:
```
lshw -C cpu | grep -i product
```
仅查看 CPU 的速度（兆赫兹）:
```
lscpu | grep -i mhz
```
或其 [BogoMips][8] 额定功率:
```
lscpu | grep -i bogo
```
**grep** 命令的 **-i** 参数代表搜索结果忽略大小写。
### 内存
Linux 命令行使你能够收集关于你的计算机内存的所有可能的详细信息。 你甚至可以不拆开电脑外壳就能确定是否可以为计算机添加额外的内存条。
使用 **dmidecode** 命令列出每根内存条和其容量:
```
dmidecode -t memory | grep -i size
```
使用以下命令获取系统内存更多的信息， 包括类型， 容量， 速度， 和电压:
```
lshw -short -C memory
```
你肯定想知道的一件事是你的计算机可以安装的最大内存:
```
dmidecode -t memory | grep -i max
```
现在检查一下计算机是否有空闲的插槽可以插入额外的内存条。 你可以通过使用命令在不打开电脑的情况下就做到:
```
lshw -short -C memory | grep -i empty
```
输出为空则意味着所有的插槽都在使用中。
确定你的电脑拥有多少显卡内存需要下面的命令。 首先使用 **lspci** 列出所有设备信息然后过滤出你想要的显卡设备信息:
```
lspci | grep -i vga
```
视频控制器的设备号输出信息通常如下:
```
`00:02.0 VGA compatible controller: Intel Corporation 82Q35 Express Integrated Graphics Controller (rev 02)`
```
现在再使用 **lspci** 命令加上视频设备号:
```
lspci -v -s 00:02.0
```
输出信息中 prefetchable 那一行显示了系统中的显卡内存大小:
```
...
Memory at f0100000 (32-bit, non-prefetchable) [size=512K]
I/O ports at 1230 [size=8]
Memory at e0000000 (32-bit, prefetchable) [size=256M]
Memory at f0000000 (32-bit, non-prefetchable) [size=1M]
...
```
最后使用下面的命令展示当前内存使用量（兆字节）:
```
free -m
```
这条命令告诉你多少内存是空闲的， 多少命令正在使用中以及交换内存的大小和是否正在使用。 例如， 输出信息如下:
```
              total        used        free     shared    buff/cache   available
Mem:          11891        1326        8877      212        1687       10077
Swap:          1999           0        1999
```
**top** 命令为你提供内存使用更加详细的信息。 它显示了当前全部内存和 CPU 使用情况并按照进程 ID， 用户 ID及正在运行的命令细分。 同时这条命令也是全屏输出:
```
top
```
### 磁盘文件系统和设备
你可以轻松确定有关磁盘， 分区， 文件系统和其他设备信息。
显示每个磁盘设备的描述信息:
```
lshw -short -C disk
```
通过以下命令获取任何指定的 SATA 磁盘详细信息， 例如其型号， 序列号以及支持的模式和扇区数量等:
```
hdparm -i /dev/sda
```
当然， 如果需要的话你应该将 **sda** 替换成 **sdb** 或者其他设备号。
要列出所有磁盘及其分区和大小， 请使用以下命令:
```
lsblk
```
使用以下命令获取更多有关扇区数量， 大小， 文件系统 ID 和 类型以及分区开始和结束扇区:
```
fdisk -l
```
要启动 Linux， 你需要确定[GRUB][9] 引导程序的安装分区。 你可以使用 **blkid** 命令找到此信息。它列出了每个分区的唯一标识符(UUID) 及其文件系统类型(例如 ext3 或 ext4):
```
blkid
```
使用以下命令列出已挂载的文件系统和它们的挂载点以及已用的空间和可用的空间（兆字节为单位）:
```
df -m
```
最后， 你可以列出所有的 USB 和 PCI 总线以及其他设备的详细信息:
```
lsusb
```
或
```
lspci
```
### 网络
Linux 提供大量的网络相关命令， 下面只是几个例子。
查看你的网卡硬件详细信息:
```
lshw -C network
```
**ifconfig** 是显示网络接口的传统命令:
```
ifconfig -a
```
但是现在很多人们使用:
```
ip link show
```
或
```
netstat -i
```
在阅读输出时， 了解常见的网络缩写十分有用:
**缩写** | **含义**
---|---
**lo** | 回环接口
**eth0** or **enp*** | 以太网接口
**wlan0** | 无线网接口
**ppp0** | 点对点协议接口（由拨号调制解调器，PPTP VPN连接或者 USB 调制解调器使用）
**vboxnet0** or **vmnet*** | 虚拟机网络接口
表中的星号是通配符， 用作系统间出现的任何字符的占位符。
使用以下命令显示默认网关和路由表:
```
ip route | column -t
```
或
```
netstat -r
```
### 软件
让我们以显示最底层软件详细信息的俩条命令来结束。 例如， 如果你想知道是否安装了最新的固件该怎么办？这条命令显示了 UEFI 或 BIOS 的日期和版本:
```
dmidecode -t bios
```
内核版本是多少以及它是 64 位的吗？ 网络主机名是什么？ 使用下面的命令查出结果:
```
uname -a
```
### 快速查询表
显示所有硬件信息 | **inxi -Fxz** 或 **hwinfo --short** 或 **lshw  -short**
---|---
CPU 信息 | **lscpu** 或 **lshw -C cpu**
显示 CPU 功能(例如 PAE, SSE2) | **lshw -C cpu \| grep -i capabilities**
报告 CPU 位数 | **lshw -C cpu \| grep -i width**
显示当前内存大小和配置 | **dmidecode -t memory \| grep -i size** 或 **lshw -short -C memory**
显示硬件支持的最大内存 | **dmidecode -t memory \| grep -i max**
确定是否有空闲内存插槽 | **lshw -short -C memory \| grep -i empty**(输出为空表示没有可用插槽)
确定显卡内存数量 | **lspci \| grep -i vga** 然后指定设备号再次使用; 例如:  **lspci -v -s 00:02.0** 显卡内存数量就是  prefetchable 的值
显示当前内存使用情况 | **free -m** 或 **top**
列出磁盘驱动器 | **lshw -short -C disk**
显示指定磁盘驱动器的详细信息 | **hdparm -i /dev/sda**(需要的话替换掉 **sda** )
列出磁盘和分区信息 | **lsblk**  (简单)   或 **fdisk -l**   (详细)
列出分区 IDs (UUIDs) | **blkid**
列出已挂载文件系统挂载点以及已用和可用空间 | **df -m**
列出 USB 设备 | **lsusb**
列出 PCI 设备 | **lspci**
显示网卡详细信息 | **lshw -C network**
显示网络接口 | **ifconfig -a** 或 **ip link show** 或 **netstat -i**
显示路由表 | **ip route \| column -t** 或 **netstat -r**
显示 UEFI/BIOS 信息 | **dmidecode -t bios**
显示内核版本网络主机名等 | **uname -a**
你有喜欢的命令被我忽略掉的吗？ 请添加评论分享给大家。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/9/linux-commands-hardware-information
作者：[Howard Fosdick][a]
选题：[lujun9972][b]
译者：[way-ww](https://github.com/way-ww)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/howtechhttps://opensource.com/users/sethhttps://opensource.com/users/sethhttps://opensource.com/users/seth
[b]: https://github.com/lujun9972
[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/features_solutions_command_data.png?itok=4_VQN3RK (computer screen )
[2]: http://sourceforge.net/projects/i-nex/
[3]: https://www.cpuid.com/softwares/cpu-z.html
[4]: http://sourceforge.net/projects/hardinfo.berlios/
[5]: https://userbase.kde.org/KInfoCenter
[6]: http://www.binarytides.com/linux-lshw-command/
[7]: http://www.disk-image.com/faq-bootmenu.htm
[8]: https://en.wikipedia.org/wiki/BogoMips
[9]: https://www.dedoimedo.com/computers/grub.html