Showing preview only (324K chars total). Download the full file or copy to clipboard to get everything.
Repository: gurugio/lowlevelprogramming-university
Branch: master
Commit: 0d662b9e77c5
Files: 14
Total size: 314.3 KB
Directory structure:
gitextract_n7o3aeqj/
├── LICENSE
├── README.md
├── README_cn.md
├── README_cz.md
├── README_es.md
├── README_fa.md
├── README_fr.md
├── README_id.md
├── README_it.md
├── README_pt.md
├── README_ru.md
├── README_tr.md
├── README_tw.md
└── _config.yml
================================================
FILE CONTENTS
================================================
================================================
FILE: LICENSE
================================================
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
{one line to give the program's name and a brief idea of what it does.}
Copyright (C) {year} {name of author}
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
{project} Copyright (C) {year} {fullname}
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
================================================
FILE: README.md
================================================
**I'm getting so much spam that I've changed this repo to read-only for a while.**
NOTICE1: Please do not copy the contents of this page to your blog. You can share this page but please share with the original link. That is how we compliment the authors of good documents and open source projects.
NOTICE2: Please notice that low-level programming is out of trend and currently there are not many companies hiring low-level developer. It is getting harder for me to find a job.
If you haven't started a professional career yet, I would like to recommend you consider other fields either carefully.
NOTICE3: If you want a quick start, go to "How to start?".
* [Low-Level Programming University](#low-level-programming-university)
* [What is it?](#what-is-it)
* [What is the Low Level](#what-is-the-low-level)
* [Theory](#theory)
* [Languages](#languages)
* [Assembly](#assembly)
* [C language](#c-language)
* [Rust language](#rust-language)
* [Applications](#applications)
* [Hardware and Firmware](#hardware-and-firmware)
* [Linux kernel and device driver](#linux-kernel-and-device-driver)
* [References](#references)
* [Other applications](#other-applications)
* [Future of low-level programming](#future-of-low-level-programming)
* [How to start?](#how-to-start)
* [Translations](#translations)
* [Who am I?](#who-am-i)
# Low-Level Programming University
## What is it?
I'm inspired by [google-interview-university](https://github.com/jwasham/coding-interview-university). I'd like to share my experience and show a roadmap to becoming a low-level programmer because I have found that these skills are not as common as they once were. In addition, many students and beginners ask me how they could become low-level programmers and Linux kernel engineers.
This page cannot include every link/book/course. For example, this page introduces Arduino but there is not detailed information about Arduino and embedded systems. You should go further yourself. You have the keyword "Arduino" with which you can start. So your next step is probably googling Arduino, buying a kit, and doing something for yourself, not collecting links or free books. Please remember this page is just a roadmap for beginners.
Low-level programming is a part of computer science.
Absolutely it would be much better to get education in computer science first.
* [Path to a free self-taught education in Computer Science!](https://github.com/ossu/computer-science)
## What is the Low-Level?
I classify low-level programming as programming that is very close to the machine, using a lower level programming language like C or assembly. This is in contrast to higher-level programming, typical of user-space applications, using high level languages (e.g. Python, Java).
* [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language)
Yes, systems programming is a very close concept to low-level programming. This page includes the hardware design and firmware development that is not included in systems programming.
* [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming)
Finally, this page includes topics ranging from hardware components to the Linux kernel. That is a huge range of layers. A one page document can never cover the details of all the layers, so the aim of this document is to serve as a starting point for low-level programming.
## Theory
There are two background theories to low-level programming:
* Computer Architecture
* Operating Systems
I think the best way to learn theory is by taking a course. Reading books is not bad but takes too much time and effort. You can find many good classes on online universities, for instance, Coursera.org and edx.org.
Theory is theory. I don't think you need to get an A+ in the class, just understand the big picture.
You'll get better and better with experience.
Let me introduce several books that I've read. They are commonly used as textbooks in universities. If there is no class with these books in your university, it's worth spending some time reading them.
* Computer Architecture
* Computer Architecture, Fifth Edition: A Quantitative Approach
* Computer Systems: A Programmer's Perspective
* Computer Organization and Design, Fourth Edition: The Hardware/Software Interface
* Operating Systems
* The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design
* The Design of the UNIX Operating System
* Operating Systems: Internals and Design Principles by William Stallings
* Recommended Courses
* [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94)
* General Programming Skill
* [Structure and Interpretation of Computer Programs](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs)
* It's about how to be a good Software programmer. You need not only theory but only technique because programming is a kind of craftwork.
* If you learn Lisp/Scheme, you should be able to learn any other language quickly.
* [I've solved about 80% exercises. It should be worth to try every single exercise.](https://github.com/gurugio/sicp_exercise)
* Hardware Design
* Build Your Own 8086 Microprocessor Kit
* If you don't build your HW board, you don't understand what physical memory mapped device is.
* Modern APs includes so many IPs. So you don't have a chance to understand how CPU core and peripheral devices are connected.
* When you build your own 8086 kit, you have a chance to locate each peripheral devices on the physical memory. And you can set how the main HW components (BUS, IRQ, Clock, Power and etc) works with your own eyes.
* I built the 8086 kit in my University. It was one of the most valuable courses I've ever taken. Try to build your own HW kit. It would be better if the HW is older ans simpler because you should do more for yourself.
* Google "8086 kit". You would be able to find some web-sites you can buy a HW scheme, parts and manuals.
There is an infinite list of good books. I don't want to say that you should read many books. Just read one book carefully. Whenever you learn a theory, implement simulation code of it. **Implementing one thing is better than knowing one hundred theories.**
## Languages
### Assembly
Choose one between x86 or ARM. No need to know both. It doesn't matter to know assembly language. The essential thing is understanding the internals of a CPU and computer. So you don't need to practice the assembly of the latest CPU. Select 8086 or Cortex-M.
* [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086)
* basic concepts of CPU and computer architecture
* basic concepts of C programming language
* [64bit assembly programming (translation in progress)](https://github.com/gurugio/book_assembly_64bit)
* basic concepts of modern CPU and computer architecture
* basic concepts of disassembling and debugging of C code
* _need help for translation_
* [Learning assembly for linux-x64](https://github.com/0xAX/asm)
* pure 64-bit assembly programming with NASM and inline assembly with GCC
* [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196)
* Complete reference on ARM programming
* Computer Organization and Design
* [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/)
* [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/)
* [RISC-V Edition](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757)
* Academic books that explain how every component of a computer work from the ground up.
* Explains in detail the different concepts that make up computer architecture.
* They are not targeted at readers who wish to become proficient in a specific assembly language.
* The MIPS and ARM edition cover the same topics but by dissecting a different architecture.
* Both editions contain examples in the x86 world
### C language
There is no shortcut. Just read the entire book and solve all the exercises.
* [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* [The C Programming Language 2nd Edition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* Modern C: Jens Gustedt. Modern C. Manning, 2019, 9781617295812. ffhal-02383654f
* For new standard of C
* [Is Parallel Programming Hard, And, If So, What Can You Do About It?](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)
* raw implementation of synchronization with C
* Essential for large scale C programming (especially for kernel programming)
* [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/)
* If you finish reading one or two C programming books, then you MUST make something.
* Choose whatever you like.
* First make on your own and then compare with someone else's source code. It is very important to compare your source and others. You can improve your skill only when you read the other's source and learn better methods. Books are dead and source is live.
* [C and other languages based projects](https://github.com/danistefanovic/build-your-own-x)
* find more interesting projects
* [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/)
* Reference on optimization using C and a bit of x86 assembly
* Starts from the 8088 up to today
* Special focus on low-level graphics optimization
* [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming)
* How to develop framework and plugin in C for large scale software
* Very basic programming tips for Linux kernel source reading
If you want to be expert of C programming, visit https://leetcode.com/. Good luck!
### Rust language
I am sure that the next language for the systems programming would be Rust.
I will make a list what I did to learn Rust.
[Linus Torvalds said "Unless something odd happens, it [Rust] will make it into 6.1."](https://www.zdnet.com/article/linus-torvalds-rust-will-go-into-linux-6-1/)
* [The Rust Programming Language](https://doc.rust-lang.org/book/)
* Great introduction, but lack of examples and exercises.
* [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
* While reading "The Rust Programming Language", you can find examples and exercises here.
* But there are not many exercises you can do something for yourself. Only some examples includes "do-this" exercises and they are very simple.
* [Programming Rust, 2nd](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/)
* Deeper introduction, but still lack of examples and exercises.
* [Exercism](https://exercism.org/tracks/rust)
* Good exercises to practice indivisual features of RUST.
* I am not sure Mentors are working actively but it would be enough to compare your solution with others.
* After submitting your solution, you can see other's solutions with "Community solutions" tab (since Exercism V3).
* Many easy level exercises are for functional feature such as map/filter/any and etc.
* [Easy rust](https://dhghomon.github.io/easy_rust/)
* A book written in easy English.
* Youtube materials provided: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk
* [Let's get rusty](https://www.youtube.com/c/LetsGetRusty)
* There are many Youtubers uploading Rust course but I enjoyed this course most.
* He has been uploading the latest news for Rust. It's worth subscribing.
* [Rust for Linux](https://github.com/Rust-for-Linux)
* See the example sources and check how Rust got into the Linux kernel
* [(Work In Progress) Linux Device Drivers in Rust](https://github.com/gurugio/rust-for-linux)
* Writing examples in the book "Linux device drivers" with the Rust language.
## Applications
### Hardware and Firmware
If you want to be an embedded systems engineer, it would be best to start from a simple hardware kit, rather than starting with the latest ARM chipset.
* [Arduino Start Kit](https://www.arduino.cc/)
* There are many series of Arduinos but "Arduino Start Kit" has the most simple processor(ATmega328P) and guide book
* ATmega328P has an 8-bit core which is a good place to start digital circuit design and firmware development.
* You don't need to know how to draw schematics and layouts and assemble the chips.
* But you do need to know how to read schematics and understand how the chips are connected.
* Firmware developers should be able to read the schematics and figure out how to send data to the target device.
* Follow the guide book!
* [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf)
* If you're a beginner to x86 architecture, 8086 is also very good guide for processor architecture and x86 assembly
* [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf)
* Best guide for protected mode and paging mechanism of 80x86 processor
* Web version: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm
At this point, you should be good to start the latest ARM or x86 processor.
* https://www.raspberrypi.org/
* https://beagleboard.org/
* https://www.arduino.cc/en/ArduinoCertified/IntelEdison
For example, the Raspberry Pi board has a Cortex-A53 Processor that supports a 64-bit instruction set.
This allows you to experience a modern processor architecture with rPi.
Yes, you can buy it... but... what are you going to do with it?
If you have no target project, you would be likely to throw the board into a drawer and forget it like other gadgets you may have bought before.
So, I recommend one project for you.
* [Making your own kernel](http://wiki.osdev.org/Getting_Started)
* Good references: https://www.reddit.com/r/osdev/
* [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* (description of the project) This repository contains a step-by-step guide that teaches how to create a simple operating system (OS) kernel from scratch...(skip)...Each lesson is designed in such a way that it first explains how some kernel feature is implemented in the RPi OS, and then it tries to demonstrate how the same functionality works in the Linux kernel.
I've made [a toy kernel](https://github.com/gurugio/caos) that supports 64-bit long mode, paging and very simple context switching. Making a toy kernel is good way to understand modern computer architecture and hardware control.
In fact, you have already the latest processor and the latest hardware devices.
Your laptop! Your desktop! You already have all that you need in order to start!
You don't need to buy anything.
The qemu emulator can emulate the latest ARM processors and Intel processors.
So everything you need is already on hand.
There are many toy kernels and documents you can refer to.
Just install qemu emulator and make a tiny kernel that just boots, turns on paging, and prints some messages.
Other toy kernels:
* https://littleosbook.github.io/
* https://tuhdo.github.io/os01/
### Linux kernel and device driver
You don't need to make a complete operating system.
Join the Linux community and participate in development.
Some resources for Linux kernel and device driver development from beginner to advanced.
* Books: Read the following in order
* [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997)
* The basic concepts of Unix are applied into all operating systems.
* This book is a very good place to learn the core concepts of operating systems.
* [Linux Device Drivers](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* Make all examples for yourself
* [Linux Kernel Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel)
* Understand the design of the Linux Kernel
* [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* Read this book and the kernel source v2.6 at the same time
* Never start with the latest version, v2.6 is enough!
* Use qemu and gdb to run the kernel source line by line
* http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu
* https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md
* Use busybox to make the simplest filesystem that takes only one second to boot
* https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md
* Other resources: Free resources I recommend
* [Linux device driver labs](https://linux-kernel-labs.github.io/)
* Practical guide and excellent exercises making Linux device drivers with essential kernel APIs
* I think this document introduces almost all essential kernel APIs.
* [The Eudyptula Challenge](http://eudyptula-challenge.org/)
* _Sadly, this challenge does not accept new challengers because there is no challenge anymore._ The maintainer said he/she is planning a new format. I hope it comes back ASAP.
* But you can find the questions of the challenge with Google. Some people already uploaded what they did. Find the questions and try to solve them on your own, and compare your solution with others.
* This is like an awesome private teacher who guides you on what to do.
* If you don't know what to do, just start this.
* [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* This project is not completed yet.
* I always think making a kernel similar to the Linux kernel is the best way to understand the Linux kernel.
* [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv)
* start from a simple block device driver example (Ramdisk) with multi-queue mode
* go forward to block layer
* I completed translation into English. Please send me your feedback.
* [md driver of Linux kernel(Korean)](https://github.com/gurugio/book_linuxkernel_md)
* how mdadm tool works and how it calls md driver
* how md driver works
* [Lions' Commentary on UNIX 6th Edition, with Source Code](https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code)
#### References
Check when you need something
* [Free-electrons homepage](http://free-electrons.com/docs/)
* many slide files introducing good topics, specially ARM-linux
* [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/)
* guide to start kernel programming
### Other applications
Yes, you might not be interested in Linux or firmware. If so, you can find other applications:
* Windows systems programming & device drivers
* Security
* Reverse engineering
I don't have any knowledge about those applications. Please send me any information for beginners.
**Kernels and drivers are not all of low-level programming.** One more important application of low-level programming is the software-defined storage or distributed filesystem. Detailed descriptions of them is beyond the scope of this document but there is an excellent course where you can try a simple distributed filesystem.
* Course: https://pdos.csail.mit.edu/archive/6.824-2012/
* reference Source: https://github.com/srned/yfs
## Future of low-level programming
I do not know the future, but I keep my eye on Rust.
* https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/
If I could have one week free and alone, I would learn Rust.
That is because Rust is the latest language with which I can develop Linux device drivers.
* https://github.com/tsgates/rust.ko
IoT is new trend, so it's worth to check what OSs are for IoT.
ARM, Samsung and some companies has their own realtime OS but sadly many of them are closed source.
But Linux Foundation also has a solution: Zephyr
* https://www.zephyrproject.org/
Typical cloud servers have many layers; for instance, host OS, KVM driver, qemu process, guest OS and service application. A container has been developed to provide light virtualization. In the near future, a new concept of OS, a so-called library OS or Unikernel, would replace the typical stack of SW for virtualization.
* http://unikernel.org/
Big data and cloud computing require bigger and bigger storage. Some disks directly attached to server machines cannot satisfy the required capacity, stability and performance. Therefore there has been research to make huge storage systems with many storage machines connected by a high speed network. It used to be focused on making one huge storage volume. But currently they are providing many volumes dedicated for many virtual machines.
* https://en.wikipedia.org/wiki/Software-defined_storage
* https://en.wikipedia.org/wiki/Clustered_file_system
* https://en.wikipedia.org/wiki/Ceph_(software)
## How to start?
I received an email asking how to start. There are many information about books, courses and projects in this page. It is my mistake to forget to write how to start. Unfortunately, there is no King's Road to [King's Landing](https://gameofthrones.fandom.com/wiki/King%27s_Landing). I will just write what I did in order. If you have already done something, please skip it. AGAIN, this is just an example that you could do in order, just in case if you do not know how to start or what to do.
* Reading OS theory books: at least "The Design of the UNIX Operating System by Maurice J. Bach"
* Learn assembly and C
* [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086)
* It is enough if you understand the concept of assembly programming. You do not need to do something practical.
* [The C Programming Language 2nd Edition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* DO YOUR BEST TO solve every single exercise!
* [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* Do something practical with C
* [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/): Find one or two interesting projects and make your own project.
* [leetcode.com](https://leetcode.com/): If you cannot find an interesting project, it would be also good to focus on data structure and algorithm.
* Do a hardware project
* Raspberrypi or Arduino does not matter. You need experience to control a hardware directly with only C. ONLY C!
* I recommend to buy a ATmega128 kit and make a firmware to turn on/off LEDs, detect switch input and display message on the text LCD. Motor control program is also a very good project: for instance, the line tracer.
* DO NOT use any library. You should make everything on your own, except program downloader.
* Basic of the Linux kernel
* Low-level programming is very close to the operating system. You should know inside of the OS.
* Start with drivers
* Read [Linux Device Drivers](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* [Linux device driver labs](https://linux-kernel-labs.github.io/)
* [The Eudyptula Challenge](http://eudyptula-challenge.org/)
* Read [Linux Kernel Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel) to understand the internal of Linux kernel.
* Go to the professional field
* If you want to be a professional Linux Kernel Developer
* must read [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* Then try to make a toy kernel
* [Learn operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* [Making your own kernel](http://wiki.osdev.org/Getting_Started)
* Write the github link to your kernel on your resume (Don't forget to write the detailed description in commit message)
* Check the latest issues at https://lwn.net/ and join it.
* Check "Recent kernel patches" at "https://lwn.net/Kernel/" or direct link https://lwn.net/Kernel/Patches
* Find an interesting patch to you. Try to understand the source code. Of course it would be really difficult but try. You will be closer and closer whenever you try.
* Build kernel and test it on your system. For example, you can run the performance tests and stability tests in LTP(https://linux-test-project.github.io/). And there are more test tools inside of kernel (https://www.kernel.org/doc/html/latest/dev-tools/index.html).
* Report any problem if you find any: compile warnings/errors, performance drop, kernel panic/oops or any problem
* If it works well, report that with the spec of your system. The patch owner would write a "Reviewed-by" tag with your name.
* Find your name in kernel git log
* Or find other topics
* There are many fields where the low-level engineer can work: security, Compiler, Firmware, robot/car and so on
# Translations
Please send me the pull request if you'd like to translate this page. I'll list it here.
* [Chinese (Traditional)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tw.md)
* [Chinese (Simplified)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md)
* [Portuguese (Brazilian)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md)
* [Italian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md)
* [Czech](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md)
* [Russian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md)
* [Turkish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tr.md)
* [Persian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fa.md)
* [Spanish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_es.md)
* [French](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fr.md)
# Who am I?
I'm inspired by [google-interview-university](https://github.com/jwasham/google-interview-university). I'd like to share my experience and show a roadmap to becoming a low-level programmer because I have found that these skills are not as common as they once were. In addition, many students and beginners ask me how they could become low-level programmers and Linux kernel engineers.
FYI, I have over 10 years of experience as a low-level programmer:
* 80x86 Assembly programming
* Hardware device with ATmel chip and firmware
* C language system programming for Unix
* Device driver in Linux
* Linux kernel: page allocation
* Linux kernel: block device driver and md module
================================================
FILE: README_cn.md
================================================
* [Low-Level Programming University](#Low-Level-Programming-University)
* [这是?](#What-is-it)
* [什么是底层](#What-Is-the-Low-Level)
* [理论](#Theory)
* [编程语言](#Languages)
* [汇编](#Assembly)
* [C语言](#C-language)
* [应用层](#Applications)
* [硬件 && 固件](#Hardware-Firmware)
* [Linux内核和设备驱动](#Linux-kernel-and-device-driver)
* [仔细阅读](#Read-carefully)
* [参考目录](#References)
* [底层编程的未来趋势](#Future-of-low-level-programming)
* [翻译](#Translation)
# <a name="Low-Level-Programming-University"></a>Low-Level Programming University
## <a name="What-is-it"></a>这是?
这篇文章是为那些准备成为一个底层程序员的人所写。
我是受到了 [google-interview-university](https://github.com/jwasham/google-interview-university) 这篇文章的启发。 作为一个底层程序员，我想分享一下我的经验和成长为一个底层程序员的路线图，因为我发现这些底层需要的技能在不断的发生变化。另外，很多学生和初学者也会经常问我，怎么才能成为一个底层程序员或者是成为一个Linux内核工程师。
本文不可能包含所有的链接/书籍/课程。例如，本文介绍了Arduino，但是没有详细介绍Arduino和嵌入式系统。读者需要自己深入学习这方面的知识。作为一个开始，你知道了关键词"Arduino"，接下来，你可以用google 搜索Arduino，购买一套开发套件，基于开发套件在上面**自己动手做一些事情**，而不是收集链接或者是免费的书籍。请记住，本文仅仅是一个路线图，是一个指导。
又及，我作为一个底层程序员，在以下方面有超过10年的经验：
* 80x86 汇编编程
* 使用基于Atmel芯片和固件的硬件
* Unix下C语言系统编程
* Linux设备驱动开发
* Linux内核: 内存页分配
* Linux内核: 块设备驱动程序和 md 模块
## <a name="What-Is-the-Low-Level"></a>什么是底层?
我把底层编程归类于非常接近设备的编程，使用比较底层的编程语言，例如C或者汇编。这与上层编程相反，例如用户空间的应用程序，使用上层的编程语言（例如，Python，Java）。
* [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language)
系统编程是一个非常接近底层编程的概念。本文包含了硬件设计以及固件开发，这部分内部不是系统编程的内容。
* [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming)
最后，本文包含的主题从硬件到Linux内核，这跨越了很多的层次。一篇文章无法阐述所有层次的详细内容，所以本文的目的是让你知道怎么开始成为一个底层程序员。
## <a name="Theory"></a>理论
底层编程有两个背景理论：
* 计算机体系结构
* 操作系统
你可以在在线大学上找到很很好的课程，例如Coursera.org and edx.org。但理论仅是理论，你不需要在这些课程上获得A+，但是你需要了解整个课程的大概原理。随着经验的丰富，你可以做得越来越好。
## <a name="Languages"></a>编程语言
### <a name="Assembly"></a>汇编
* [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086)
* CPU和计算机体系结构的基本概念
* C语言的基本概念
* [64bit assembly programming(正在翻译)](https://github.com/gurugio/book_assembly_64bit)
* 现代CPU和计算机体系结构的基本概念
* 分解和调试C语言的基本概念
* _需要帮忙翻译_
* [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196)
* ARM编程参考手册
* 计算机组成和设计
* [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/)
* [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/)
* 学术书籍，解释了计算机的各部分是如何从0开始工作的
* 详细解释了计算机体系结构中各方面概念
* 他们的目的不是让你成为特定汇编语言专家
* MIPS和ARM版本阐述了同样的问题，只不过他们以不同的体系结构为例
* 两个版本都包含了x86结构下的例子
### <a name="C-language"></a>C 语言
学习C语言没有捷径，你需要读完整本书，并解决书上的练习题。
* [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* [The C Programming Language 2nd Edition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* [Modern C](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf)
* C语言新标准
* [并行编程困难吗，如果是的，你能做点什么?](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)
* 用C语言实现同步
* 大型C程序设计必备 (特别是Linux内核编程)
* [C语言编程的挑战?](https://github.com/gurugio/lowlevelprogramming-university/blob/master/c-language-challenge.md)
* 开始为[The Eudyptula Challenge](http://eudyptula-challenge.org/) 制作计划
* 当前只有一个想法
* 如果你完成了本文的所有小项目，那么你已经可以开始做大的项目了
* [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/)
* 使用C语言和x86汇编进行优化的参考书籍
* 从8088系统到现在的系统
* 特别注重底层的图形优化
## <a name="Applications"></a>应用程序
### <a name="Hardware-Firmware"></a>硬件 && 固件
如果你想做一个嵌入式系统工程师，那最好从一个简单的硬件套件开始，而不是从最新的ARM芯片开始。
* [Arduino Start Kit](https://www.arduino.cc/)
* Arduino有一系列的套件，但是 "Arduino Start Kit"有最简单的处理器(Atmega328P)以及参考手册。
* Atmega328P有一个8位的核心，这对于“数字电路设计”和“固件开发” 是个好的开头
* 你不必要了解怎么画原理图，怎么laytou，怎么组装芯片
* 但是你需要知道怎么去读原理图，并理解各芯片之间是怎么连接的
* 固件工程师应该具备阅读原理图并知道怎么给目标设备发送数据的能力
* 跟随参考手册的指导
* [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf)
* 如果你刚开始了解x86架构，8086手册对于理解处理器架构和80x86汇编语言也是非常好的指导
* [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf)
* 对于80x86处理器的保护模式和分页机制是最好的指导
* 网络版本: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm
到这个点上，你可以开始了解最新的ARM和x86处理器。
* https://www.raspberrypi.org/
* https://beagleboard.org/
* https://www.arduino.cc/en/ArduinoCertified/IntelEdison
例如，树莓派开发板有一个支持64位指令的Cortex-A53处理器，这可以让你了解现代处理器架构。是的，你可以买一个开发板，但是，你买来做什么呢？如果你没有目标项目，你很可能将它扔到抽屉里，然后忘在脑后。
所以，我向你推荐一个项目：
* [制作自己的内核](http://wiki.osdev.org/Getting_Started)
* 参考资料: https://www.reddit.com/r/osdev/
我自己制作了[a toy kernel](https://github.com/gurugio/caos)，该内核支持64位长模式，分页以及很简单的上下文切换。制作一个简单的内核对于理解现代计算机体系结构和硬件控制是一种很好途径。
事实上，你已经有了最新的处理器和最新的硬件设备。这就是你的笔记本电脑，你的台式电脑，你已经具备所有的条件了。你不需要购买任何东西。qemu仿真器可以仿真最新的ARM和Intel处理器，所以你需要的资料都已经具备了。有很多简单内核和文档供你参考。你要做的就是安装qemu仿真器，开发一个简单内核，能够启动，开启分页功能并打印一些信息。
其他的简单内核:
* https://littleosbook.github.io/
* https://tuhdo.github.io/os01/
### <a name="Linux-kernel-and-device-driver"></a>Linux内核和设备驱动
你没有必要开发一个完整的操作系统，可以加入Linux社区并参与内核开发。
#### <a name="Read-carefully"></a>仔细阅读
* 书籍: 按照如下顺序阅读
* [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997)
* Unix系统的基本概念适用于所有的操作系统
* 这本书对于理解操作系统概念非常好
* [Linux Device Drivers](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* 亲自做所有的例子
* [Linux Kernel Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel)
* 理解Linux内核设计原理
* [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* 读这本书的同时也要读v2.6的内核源码
* 不要读最新的源码，2.6版本足够了!
* 使用quemu和gdb来一行一行的运行内核代码
* http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu
* https://gurugio.kldp.net/wiki/wiki.php/howto_debug_kernel
* 使用busybox来制作最简单的文件系统，使得系统能在1秒内启动
* https://gurugio.kldp.net/wiki/wiki.php/qemu_kernel
* [The Eudyptula Challenge](http://eudyptula-challenge.org/)
* 这就像一个令人敬畏的私人老师指导你该做什么
* 如果你不知道做什么，那就从这里开始
* [Block layer and device driver(正在翻译)](https://github.com/gurugio/book_linuxkernel_blockdrv)
* 从一个简单的具备多队列模式的块设备驱动程序（Ramdisk）开始
* 深入到块设备层
* _需要帮忙翻译_
* [md driver of Linux kernel(正在进行)](https://github.com/gurugio/book_linuxkernel_md)
* mdadm工具工作流程以及调用md驱动程序的过程
* md驱动程序是怎么工作的
* _需要帮忙翻译_
#### <a name="References"></a>参考
当你需要帮助时参考下面资料
* [Free-electrons homepage](http://free-electrons.com/docs/)
* 很多文件介绍的内容都很好，尤其是ARM-linux方面的
* [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/)
* 指导如何开始内核编程
## <a name="Future-of-low-level-programming"></a>底层编程的未来趋势
我不知道未来会怎么样，但是我会关注RUST。
* https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/
如果我有一周的空闲时间，我会学习RUST。这是因为RUST是可以开发Linux设备驱动程序的最新的一种语言。
IoT是新的趋势，所以值得我们去研究一下IoT所使用的操作系统。ARM，Samsung以及一些公司有他们自己的实时操作系统，但是糟糕的是这些系统都是闭源的。但是Linux基金会有一个解决方案：Zephyr
* https://www.zephyrproject.org/
典型的云服务器有很多层，例如主机OS，kvm驱动，qemu进程，客机OS以及应用服务程序。因此容器被开发出来以提供轻量虚拟化。在不久的将来，一种新型的OS，被称为library OS或者是Unikernel的OS，可能会取代当前的用作虚拟化的软件栈。
* http://unikernel.org/
# <a name="Translation"></a>Translation
如果你要翻译本文，请提交一个PR，我会在这里列出来。
================================================
FILE: README_cz.md
================================================
# PROSBA O POMOC!
Prosím informujte mě (ticketem nebo pomocí pull) jestli víte o nějakých dobrých odkazech na :
* **Programování Hardwaru firmwaru**
* **Qemu/KVM hypervisor**
* **Síťový zásobník jádra**
----
* [Univerzita nízkoúrovňového programování](#Low-Level-Programming-University)
* [Co to je?](#What-is-it)
* [Co to je nízkoúrovňové](#What-Is-the-Low-Level)
* [Teorie](#Theory)
* [Jazyky](#Languages)
* [Assembly](#Assembly)
* [Jazyk C](#C-language)
* [Aplikace](#Applications)
* [Hardware && Firmware](#Hardware-Firmware)
* [Linuxové jádro a ovladač zařízení](#Linux-kernel-and-device-driver)
* [Pečlivě prostudujte](#Follow-carefully)
* [Odkazy](#References)
* [Jiné aplikace](#Other-applications)
* [Budoucnost nízkoúrovňového programování](#Future-of-low-level-programming)
* [Překlad](#Translation)
* [Kdo jsem?](#who-am-i)
# Univerzita nízkoúrovňového programování
## <a name="What-is-it"></a>Co to je?
Jsem inspirován [google-interview-university](https://github.com/jwasham/coding-interview-university). Rád bych se podělil o zkušenosti a ukázal cestu, jak se stát nízkoúrovňovým programátorem, protože jsem zjistil, že tyto dovednosti nejsou tak běžné jako byly kdysi. Navíc se mě mnoho studentů a začátečníků ptá, jak by se mohli stát nízkoúrovňovým programátorem a inženýrem Linuxového jádra.
Tato stránka nemůže obsahovat všechny odkazy/knihy/kurzy. Například tato stránka představuje Arduino, ale nejsou zde detailní informace o Arduinu a vestavěných systémech. Dál už musíte sami. Máte heslo "Arduino" se kterým můžete začít. Takže vaším dalším krokem bude pravděpodobně progooglování Arduina, a nakoupení sady a udělání něčeho samostatně a ne sbírání odkazů a knih co jsou zadarmo. Prosím mějte napaměti, že tato stránka je pouze plánek pro začátečníky.
## <a name="What-Is-the-Low-Level"></a>Co to je nízkoúrovňové?
Za nízkoúrovňové programování považuji takové programování, které má velmi blízko ke stroji, používání nízkoúrovňových jazyků jako C a assembly. Toto je v kontrastu s vysokoúrovňovým programováním, typickým pro aplikace uživatelského prostoru, používajícím vysokoúrovňové jazyky (např. Python, Java).
* [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language)
Ano, programování systémů má velmi blízko ke konceptu nízkoúrovňového programování. Tato stránka zahrnuje navrhování hardwaru a nasazování firmwaru, které systémové programování neobsahuje.
* [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming)
Takže tato stránka zahrnuje témata spadající mezi hardwarové komponenty a Linuxové jádro. To je velký rozsah různých rovin. Dokument o jedné straně nemůže nikdy pokrýt detaily každé z nich, a tak se tento dokument zaměřuje na to stát se odrazovým můstkem pro nízkoúrovňové programování.
## <a name="Theory"></a>Teorie
Základní teorie pro nízkoúrovňové programování jsou dvě:
* Stavba (architektura) počítače
* Operační systémy
Myslím, že nejlepší cestou jak se naučit teorii je zúčastnit se kurzu. Čtení knih není špatné, ale zabere příliš mnoho času a úsilí. Můžete najít spoustu dobrých kurzů na online univerzitách, například na Coursea.org a edx.org.
Teorie je teorie. Nemyslím, že musíte obdržet nejlepší známku, jde o to udělat si obrázek.
Stále se budete zlepšovat zkušenostmi.
Nechte mě představit vám pár knih, které jsem přečetl. Běžně se používají jako skripta na univerzitách. Pokud nebude kurz s těmito knihami na vaší univerzitě, stojí za to přečíst si je.
* Počítačová architektura
* Computer Architecture, Fifth Edition: A Quantitative Approach
* Computer Systems: A Programmer's Perspective
* Computer Organization and Design, Fourth Edition: The Hardware/Software Interface
* Operační systémy
* The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design
* The Design of the UNIX Operating System
* Operating Systems: Internals and Design Principles by William Stallings
* Doporučené kurzy
* [CS401: Operating Systems from saylor.org](https://learn.saylor.org/mod/page/view.php?id=921)
Existuje nepřeberné množství dobrých knih. Nechci tím říci, že by jste měli přečíst hodně knih. Hlavně přečtěte jednu důkaldně. Kdykoli se naučíte teorii, simultánně implementujte její kód. **Implementování jedné věci je lepší než znát jedno sto teorií.**
## <a name="Languages"></a>Jazyky
### <a name="Assembly"></a>Assembly
Vyberte si jeden mezi x86 a ARM. Nemusíte znát oba. Nezáleží na tom znát assembly jazyk. Hlavní věcí je porozumění vnitřním procesů CPU a počítače. Takže nemusíte cvičit assemly posledních CPU. Vyberte si 8086 nebo Cortex-M.
* [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086)
* základní koncepty CPU a počítačové architektury
* základní koncepty programovacího jazyka C
* [64bit assembly programming(na překladu ještě pracuji)](https://github.com/gurugio/book_assembly_64bit)
* základní koncepty moderní CPU a počítačové architektury
* základní koncepty převodu ze strojového kódu a opravování kódu v jazyce C
* _potřebuji pomoci s překladem_
* [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196)
* Kompletní reference o ARM programování
* Organizace počítače a design
* [MIPS edice](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/)
* [ARM edice](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/)
* [RISC-V edice](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757)
* Akademické knihy, které vysvětlují jak jednotlivé komponenty počítače pracují od základů.
* Detailně vysvětlují rozdílné koncepty, které tvoří stavbu počítače.
* nejsou určeny čtenářům, kteří se chtějí stát zdatnými v určitém assembly jazyku.
* MIPS a ARM edice pokrývají ta samá témata, ale rozpitvávají rozdílné architektury.
* Obě edice obsahují příklady ve světě x86.
### <a name="C-language"></a>Jazyk C
Tady neexistuje zkratka. Jen přečtěte jednu celou knihu a vyřešte všechny příklady.
* [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* [The C Programming Language 2nd Edition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* [Modern C](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf)
* Pro nový standard C
* [Is Parallel Programming Hard, And, If So, What Can You Do About It?](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)
* hrubá implementace a synchronizace s C
* Základy pro rozsáhlé C programování (zvláště pro programování jádra)
* [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/)
* Poté, co přečtete jednu či dvě knihy o programování v C, ihned MUSÍTE něco dělat.
* Vyberte si, co chcete.
* Nejdříve něco vytvořte a potom porovnejte s kódem někoho jiného. To je velmi důležité porovnávání vašeho zdrojového kódu s ostatními. Můžete zdokonalit vaše dovednosti pouze čtením cizího zdrojového kódu a učením se lepším metodám. Knihy jsou mrtvé, ale zdrojový kód živý.
* [Projekty založené na C a dalších jazycích](https://github.com/danistefanovic/build-your-own-x)
* najděte si více zajímavých projektů
* [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/)
* Reference na optimalizaci za použití C a části x86 assembly
* Začíná 8088 a pokračuje až do současnoti
* Speiálně se zaměřuje na nízkoúrovňovou grafickou optimalizaci
Chcete-li být expertem na programování v C, navštivte https://leetcode.com/. Hodně štěstí!
## <a name="Applications"></a>Aplikace
### <a name="Hardware-Firmware"></a>Hardware && Firmware
Jestli chcete být inženýrem vázaných systémů, nejlépe bude začít jednoduchou soupravou hardwaru, než začít s nejnovějším ARM chipsetem.
* [Arduino Start Kit](https://www.arduino.cc/)
* K dispozici je mnoho sérií Arduina, ale "Arduino Start Kit" má nejjednodušší procesor(Atmega328P) a knihu návodů.
* Atmega328P má osmi bitové jádro, což je dobré místo, kde začít s navrhováním digitálních obvodů a vývojem firmwaru.
* Nepotřebujete vědět jak kreslit schémata a plánky a sestavit čip.
* Musíte ale vědět, jak číst schémata a porozumět zapojení čipů.
* Vývojáři firmwaru by měli být schopni číst schémata a zjistit, jak poslat data do cílového zařízení.
* Postupujte podle knihy návodů!
* [8086 manuál](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf)
* Pokud jste nováčkem co se týká x86 architektury, 8086 je také velmi dobrý návod co do stavby procesoru a 80x86 assembly
* [80386 manuál](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf)
* Nejlepší návod pro chráněný mód a stránkovací mechanismus procesorů 80x86
* Webovská verze: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm
V tomto bodě by jste měli být dost dobří na to začít s nejnovějšími ARM nebo x86 procesory.
* https://www.raspberrypi.org/
* https://beagleboard.org/
* https://www.arduino.cc/en/ArduinoCertified/IntelEdison
Například Raspberry Pi deska má Cortex-A53 procesor, který podporuje 64-bitové sady instrukcí.
To vám dovoluje si vyzkoušet moderní procesorovou architekturu s rPi.
Ano, můžete si ti koupit... ale... co s tím budete dělat?
Pokud nemáte žádný cílový projekt, můžete klidně desku hodit do šuplíku a zapomenout na ni jako na další věcičky, co jste nakoupili předtím.
Takže vám doporučuji jeden projekt.
* [Vytvoření vlastního jádra](http://wiki.osdev.org/Getting_Started)
* Dobré podklady: https://www.reddit.com/r/osdev/
* [Naučení se vyvíjet operační systém za použití Linuxového jádra a Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* (popis projektu) Toto úložiště obsahuje návod, který vás krok za krokem naučí, jak vytvořit jednoduché jádro operačního systému (OS) z ničeho... Každá lekce je navržena tak, že nejdříve vysvětlí, jak je jádrová vlastnost implementována do RPi OS, a potom se snaží předvést, jak ta samá funkce pracuje v Linuxovém jádře.
Vytvořil jsem [jádro na hraní](https://github.com/gurugio/caos) které podporuje 64-bitově délkový mód, stránkující a ve velmi jednoduchém kontextu přepínající. Udělání jádra na hraní je dobrá cesta k porozumění moderní počítačové architektuře a kontroly nad hardwarem.
V podstatě poslední procesor a poslední hardwarové prostředky už máte. Svůj laptop! Svůj desktop! Máte všechno, co potřebujete k tomu začít!
Nemusíte nic kupovat.
Qemu emulátor může napodobit poslední ARM procesory a procesory Intel.
Takže všechno, co potřebujete, už máte v rukou.
Je mnoho jader na hraní a dokumentací z kterých můžete těžit.
Stačí si nainstalovat qemu emulátor a vyrobit drobné jádro, které bootuje, začne stránkovat a tiskne zprávy.
Další jádra na hraní:
* https://littleosbook.github.io/
* https://tuhdo.github.io/os01/
### <a name="Linux-kernel-and-device-driver"></a>Linuxové jádro a ovladač zařízení
Nepotřebujete vytvořit kompletní operační systém.
Připojete se ke komunitě a podílejte se na vývoji.
#### <a name="Follow-carefully"></a>Důsledně nastudujte
* Knihy: Přečtěte v následujícím pořadí
* [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997)
* Základní koncepty Unixu jsou aplikovány do všech operačních systémů.
* Tato kniha je dobrým místem, kde se naučit základní postupy operačních systémů.
* [Linux Device Drivers](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* Sami vyřešte všechny příklady
* [Linux Kernel Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel)
* Porozumějte designu Linuxového jádra
* [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* Přečtěte tuto knihu a zdrojový kód jádra v2.6 zároveň
* Nikdy nezačínejte s nejnovější verzí, v2.6 je dostačující!
* Použijte qemu a gdb ke spouštění zdrojového kódu jádra řádek po řádku
* http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu
* https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md
* Použijte busybox k vytvoření toho nejjednoduššího systému souborů, jehož bootování zabere pouze jednu sekundu
* https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md
* Jiné zdroje: Ze zdrojů, co jsou zadarmo doporučuji
* [Linux device driver labs](https://linux-kernel-labs.github.io/)
* Praktický průvodce a vynikající příklady vytváření Linuxových ovladačů zařízení se základními jádrovými aplikacemi
* Myslím, že tento dokument představuje téměř všechny podstatné jádrové aplikace.
* [The Eudyptula Challenge](http://eudyptula-challenge.org/)
* _Bohužel, tento úkol nepřijímá další účastníky, protože se tu už žádná výzva nevyskytuje._ Správce řekl, že plánuje nový formát. Doufám, že to bude co nejdříve.
* Můžete ale nalézt podněty k výzvám přes Google. Někteří už nahráli, co vytvořili. Najděte úkoly a snažte se je sami vyřešit a porovnejte svoje řešení s ostatními.
* To je jako zatraceně dobrý soukromý učitel, který vás vede k tomu, co by se mělo dělat.
* Jesliže nevíte, co dělat, prostě začněte tímto.
* [Blokovací vrstva a ovladač zařízení](https://github.com/gurugio/book_linuxkernel_blockdrv)
* začněte jednoduchým příkladem blokovacího ovladačem zařízení (Ramdisk) s multi-frontovým módem
* jděte dál až ke blokovací vrstvě
* Dokončil jsem překlad do angličtiny. Dejte mi prosím zpětnou vazbu.
* [md ovladač Linuxového jádra (korejsky)](https://github.com/gurugio/book_linuxkernel_md)
* jak mdadm nástroj funguje a jak volá md ovladač
* jak md ovladač funguje
* [Učení se vývoji operačního systému za použití Linuxového jádra a Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* Tento projekt ještě není dokončen.
* Vždy si myslím, že vytvoření jádra podobného tomu Linuxovému je nejlepší cestou k porozumění jádra Linuxu.
#### <a name="References"></a>Dokumentace
Projděte, když něco potřebujete
* [Domovská stránka volné elektroniky](http://free-electrons.com/docs/)
* mnoho souborů s prezentacemi představujícími dobrá témata, hlavně ARM-linux
* [Blogy Julie Evansové: Můžeš být jádrový hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/)
* návod, jak začít s programováním jádra
### <a name="Other-applications"></a>Jiné aplikace
Ano, nemusí vás zajímat Linux nebo firmware. Pokud tomu tak je, můžete nalézt jiná uplatnění:
* Programování systému Windows & ovladače zařízení
* Zabezpečení
* Reverzní inženýrství
Nemám žádné znalosti o těchto uplatněních. Prosím pošlete mi nějaké informace pro začátečníky.
**Nízkoúrovňové programování nejsou jenom jádra a ovladače.** Je ještě jedno důležité uplatnění nízkoúrovňového programování a to je softwarově ovládané úložiště nebo poskytovaný systém souborů. Jejich detailní popis již spadá mimo rámec tohoto dokumentu, ale existuje jeden vynikající kurz, kde si můžete jednoduchý poskytovaný systém souborů vyzkoušet.
* Kurz: https://pdos.csail.mit.edu/archive/6.824-2012/
* zdrojový kód dokumentace: https://github.com/srned/yfs
## <a name="Future-of-low-level-programming"></a>Budoucnost nízkoúrovňového programování
Neznám budoucnost, ale sleduji RUST.
* https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/
Kdybych měl týden volna, učil bych se RUST.
A to proto, že RUST je nejnovější jazyk se kterým mohu vyvíjet Linuxové ovladače zařízení.
* https://github.com/tsgates/rust.ko
IoT (internet věcí) je nový trend, takže by stálo za to podívat se, jaký operační systém se pro IoT používá.
ARM, Samsung a některé další společnosti mají svůj vlastní real-time operační systém, ale bohužel mnoho z nich má uzavřený zdrojový kód.
Ale Linux Foundation má také řešení: Zephyr
* https://www.zephyrproject.org/
Typické serevery cloudů mají mnoho vrstev; například, hostitelský operační systém, kvm ovladač, qemu proces, hostující operační systém a servisní aplikace. K nenáročné virtualizaci byl vyvinut kontejner. V blízké budoucnosti by měl nový koncept OS, takzvaný OS knihoven nebo Unikernel, nahradit typické zásobníky softwaru pro virtualizaci.
* http://unikernel.org/
Velká data a používání cloudů vyžaduje stále větší a větší úložiště. Disky přímo přiložené k serverům nemohou uspokojit požadovanou kapacitu, stabilitu a výkon. Proto byl učiněn výzkum k vytvoření obrovských úložných systémů s mnoha úložnými zařízeními propojených vysokorychlostní sítí. Původně to bylo zaměřené na sestavení jednoho velkého úložného souboru. Ale v současné době se provozuje větší počet souborů pro mnoho virtuálních přístrojů.
* https://en.wikipedia.org/wiki/Software-defined_storage
* https://en.wikipedia.org/wiki/Clustered_file_system
* https://en.wikipedia.org/wiki/Ceph_(software)
# <a name="Translation"></a>Překlad
Prosím pošlete mi pull request, pokud chcete přeložit tuto stránku. Uvedu jej zde.
* [čínština](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md)
* [portugalština (Brazílie)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md)
* [italština](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md)
# <a name="who-am-i"></a>Kdo jsem?
Jsem inspirován [google-interview-university](https://github.com/jwasham/google-interview-university). Rád bych se podělil o zkušenosti a ukázal návod jak se stát nízkoúrovňovým programátorem, protože jsem zjistil, že tyto dovednosti nejsou tak běžné jako kdysi byly. Navíc se mě mnoho studentů a začátečníků ptá, jak by se mohli stát nízkoúrovňovým programátorem a inženýrem Linuxového jádra.
Pro vaši informaci, mám přes deset let zkušeností coby nízkoúrovňový programátor:
* 80x86 Assembly programování
* Hardwarová zařízení s čipem Atmel a firmware
* Systémové programování v jazyku C pro Unix
* Ovladače zařízení v Linuxu
* Linuxové jádro: stránková alokace
* Linuxové jádro: blokovací ovladač zařízení a md modul
================================================
FILE: README_es.md
================================================
NOTA1: Por favor, no copies el contenido de esta página a tu blog. Puedes compartir esta página, pero, por favor, compártela con el enlace original. Así es como agradecemos a los autores de buenos documentos y proyectos de código abierto
NOTA2: Por favor, téngase en cuenta que la programación a bajo nivel no está de moda y actualmente no hay muchas compañías contratando programadores de bajo nivel. Cada vez es más difícil encontrar trabajo de esto.
Si no has iniciado tu carrera profesional todavía, te recomiendo que consideres otros campos cuidadosamente.
NOTA3: Si quieres un inicio rápido, ve a la sección "¿Cómo empezar?"
* [Universidad de programación a bajo nivel](#Universidad-de-programación-a-bajo-nivel)
* [Qué es](#Qué-es)
* [Qué es el bajo nivel](#Qué-es-el-bajo-nivel)
* [Teoría](#Teoría)
* [Lenguajes](#Lenguajes)
* [Ensamblador](#Ensamblador)
* [Lenguaje C](#Lenguaje-C)
* [Lenguaje Rust](#Lenguaje-Rust)
* [Aplicaciones](#Aplicaciones)
* [Hardware y firmware](#Hardware-y-firmware)
* [Núcleo Linux y controladores de dispositivos](#Núcleo-Linux-y-controladores-de-dispositivos)
* [Referencias](#Referencias)
* [Otras aplicaciones](#Otras-Aplicaciones)
* [Futuro del bajo nivel](#Futuro-del-bajo-nivel)
* [Cómo empezar](#Cómo-empezar)
* [Traducción](#Traducción)
* [Quién soy](#Quién-soy)
# Universidad de programación a bajo nivel
## <a name="Qué-es"></a>¿Qué es?
Me inspiré en [google-interview-university](https://github.com/jwasham/coding-interview-university). Me gustaría compartir mi experiencia y mostrar un mapa de ruta para convertirse en un programador a bajo nivel porque he visto que estas habilidades ya no son tan comunes como fueron una vez. Además, muchos estudiantes y principiantes me preguntan cómo convertirse en programadores a bajo nivel e ingenieros del núcleo de Linux.
Esta página no puede incluir todos los enlaces, libros o cursos. Por ejemplo, esta página introduce Arduino, pero no información detallada sobre su relación con los sistemas embebidos. Deberás profundizar tú mismo. Tienes la palabra clave "Arduino" con la que empezar. Así que tu siguiente paso probablemente sea buscarla en Google, comprarte un kit y hacer algo por ti mismo, no acumular enlaces o libros gratis. Por favor, recuerda que esta página es sólo un mapa de ruta para principiantes.
La programación a bajo nivel es una parte de las ciencias de la computación.
Por supuesto, será mucho mejor educarse un poco sobre las ciencias de la computación primero.
* [Ruta para una educación autodidacta en ciencias de la computación](https://github.com/ossu/computer-science)
## <a name="Qué-es-el-bajo-nivel"></a>¿Qué es el bajo nivel?
Clasifico la programación a bajo nivel como aquella que es muy cercana a la máquina, usando un lenguaje de programación con capacidades de bajo nivel como C o ensamblador. En la otra mano está la programación a alto nivel, típica de las aplicaciones de espacio de usuario, utilizando lenguajes de alto nivel como Python o Java.
* [Wikipedia: Lenguaje de bajo nivel](https://es.wikipedia.org/wiki/Lenguaje_de_bajo_nivel)
Sí, la programación de sistemas es un concepto muy cercano a la programación a bajo nivel. Esta página incluye el diseño hardware y el desarrollo de firmware, que no forman parte de la programación de sistemas.
* [Wikipedia en inglés: Systems Programming](https://en.wikipedia.org/wiki/Systems_programming)
Por último, esta página incluye temas desde los componentes hardware hasta el núcleo Linux. Es un rango enorme con muchas capas. Un documento de una página nunca podría cubrir los detalles de todas ellas, así que el objetivo de este documento es servir como un punto de partida para la programación a bajo nivel.
## <a name="Teoría"></a>Teoría
La base teórica de la programación a bajo nivel tiene dos componentes principales:
* La arquitectura de computadoras
* Los sistemas operativos
Pienso que la mejor forma de aprender la teoría es tomando un curso. Leerse un libro no es mala opción, pero toma demasiado tiempo y esfuerzo. Puedes encontrar buenas clases en universidades en línea, por ejemplo [Coursera](https://www.coursera.org) y [edx](https://www.edx.org).
La teoría es teoría. No creo que necesites tener un 10 en clase, sólo entiende el panorama general.
La experiencia te hará cada vez mejor.
Déjame introducir varios libros que he leído. Son usados comúnmente como libros de texto en universidades. Si no hay ninguna clase con estos libros en tu universidad, merece la pena invertir un tiempo en leerlos. Muchos están en inglés, así como sus títulos:
* Arquitectura de computadoras
* Computer Architecture: A Quantitative Approach, quinta edición.
* Computer Systems: A Programmer's Perspective.
* Computer Organization and Design: The Hardware/Software Interface, cuarta edición.
* Sistemas operativos
* The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design.
* The Design of the UNIX Operating System.
* Operating Systems: Internals and Design Principles by William Stallings.
* Cursos recomendados
* [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94)
* Habilidad general de programación
* [Estructura e interpretación de los programas de ordenador](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs)
* Trata sobre cómo ser un buen programador. No necesitas sólo teoría, sino sólo técnica porque programar es un tipo de artesanía.
* Si aprendes [Lisp](https://es.wikipedia.org/wiki/Lisp)/[Scheme](https://es.wikipedia.org/wiki/Scheme), deberías poder aprender cualquier otro lenguaje rápido.
* [He resuelto aproximadamente el 80% de los ejercicios. Valdría la pena intentarlos todos](https://github.com/gurugio/sicp_exercise)
* Diseño Hardware
* Kit para construir tu propio microprocesador 8086
* Si no te construyes tu propia placa HW, no entenderás lo que es un dispositivo con memoria física mapeada.
* Casi todo el hardware moderno está plagado de IPs (Propiedad Intelectual) de forma que no podrás saber cómo están conectados los procesadores con los periféricos, etc.
* Cuando te haces tu propio kit 8086 podrás ver cómo está todo conectado, podrás encontrar los periféricos en la memoria física, cómo funcionan los componentes HW con tus propios ojos, etc.
Hay una listas infinita de libros buenos. No quiero decir que deberías leerlos todos, simplemente lee alguno cuidadosamente. Mientras aprendes la teoría, intenta implementar en código algo relacionado con ello. Implementar una cosa es mejor que conocer cien en teoría.
## <a name="Lenguajes"></a>Lenguajes
### <a name="Ensamblador"></a>Ensamblador
Elige uno entre x86 o ARM. No necesitas saber ambos y tampoco importa si no sabes escribirlo, pero será esencial entender el funcionamiento interno de un procesador. No necesitas practicar el ensamblador del último procesador. Elige 8086 o Corex-M.
* [Programación en ensamblador de 8086 con emu8086](https://github.com/gurugio/book_assembly_8086)
* Conceptos básicos de un procesador y de la arquitectura de computador.
* Conceptos básicos del lenguaje C.
* [Programación en ensamblador x64 (traducción en curso)](https://github.com/gurugio/book_assembly_64bit)
* Conceptos básicos de arquitecturas y procesadores modernos.
* Conceptos básicos de desensamblado y depurado de código C.
* _se necesita ayuda con la traducción_.
* [Aprendiendo ensamblador para Linux-x64](https://github.com/0xAX/asm)
* Programación en puro ensamblador de 64-bits con NASM y programación de *inline assembly* con GCC.
* [Manual de refernecia de la arquitectura ARM](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-97802017)
* Referencia completa para la programación en ARM.
* Estructura y diseño de computadoras
* [Edición MIPS](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/)
* [Edición ARM](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/)
* [Edición RISC-V](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757)
* Libros académicos que explican cómo funcionan los componentes de una computadora.
* Explican en detalle los diferentes conceptos que forman parte de la arquitectura de la computadora.
* No son para aquellos lectores que quieran profundizar en un dialecto específico de ensamblador.
* Las ediciones de MIPS y ARM cubern los mismos temas pero diseccionando una arquitectura diferente.
* Ambas ediciones contienen ejemplos del mundo real en x86.
### <a name="Lenguaje C"></a>Lenguaje C
* [Programación en C: Una aproximación moderna, 2ª edición](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* [El lenguaje de programación C: 2ª edición](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* Modern C: Jens Gustedt. Modern C. Manning, 2019, 9781617295812. ffhal-02383654f
* For new standard of C
* [¿Es la progrmación paralela difícil? Y, de serlo, ¿Qué puedes hacer acerca de ello?](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)
* Ejemplo de sincronización con C.
* Esencial para programación en C a gran escala (sobretodo para programación de núcleos de sistemas operativos).
* [Tutoriales de C de tipo proyecto](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/)
* Después de terminar uno o dos libros sobre C, es importante ponerse a hacer algo con ello.
* Haz tu versión primero y luego compárala con la de los demás. Es importante comparar tu código con el de otros. Puedes mejorar tus habilidades a partir de leer el código de otros.
* [Proyectos basados en C y otros lenguajes](https://github.com/danistefanovic/build-your-own-x)
* Sirve para encontrar proyectos interesantes.
* [El libro negro de la programación gráfica, por Michael Abrash. Edición especial](http://www.jagregory.com/abrash-black-book/)
* Referencia acerca de la optimización en C y un poco de ensamblador de x86.
* Comienza con el 8088 y progresa hasta hoy.
* Énfasis en la optimización de gráficos a bajo nivel.
* [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming)
* Cómo desarrollar frameworks y plugins en C para software de gran escala.
* Pistas básicas de programación para leer el código del núcleo Linux.
Si quieres convertirte en un experto de la programación en C, visita [Leetcode](https://leetcode.com/). ¡Buena suerte!
### <a name="Lenguaje-Rust"></a>Lenguaje Rust
Estoy convencido de que Rust será el siguiente lenguaje para la programación de sistemas.
Haré una lista con lo que yo hice para aprender Rust.
[Linus Torvalds dijo "A no ser que algo suceda, [Rust] entrará en la versión 6.1."](https://www.zdnet.com/article/linus-torvalds-rust-will-go-into-linux-6-1/)
* [El lenguaje de programacíón Rust](https://doc.rust-lang.org/book/)
* Es una buena introducción, pero le faltan ejemplos y ejercicios.
* [Rust a través de ejemplos](https://doc.rust-lang.org/rust-by-example/)
* Mientras lees "El lenguaje de programación Rust", puedes encontrar los ejemplos y los ejercicios en este.
* Pero no contiene demasiados ejercicios en los que puedes hacer algo por ti mismo. Sólo algunos ejemplos incluyen ejercicios de "haz esto", y son muy simples.
* [Programando Rust, 2ª](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/)
* Introducción más en profundidad, pero siguen faltando ejercicios y ejemplos.
* [Exercism](https://exercism.org/tracks/rust)
* Buenos ejercicios para practicar características individuales de Rust.
* No estoy seguro de que los Mentores estén funcionando activamente, pero sería suficiente para comparar tus soluciones con las de otros.
* Después de subir tu solución puedes ver las de otros en la pestaña de "Community solutions" (Exercism V3).
* Muchos ejercicios de nivel fácil son para funcionalidades de tipo map/filter/any, etc.
* [Easy rust](https://dhghomon.github.io/easy_rust/)
* Un libro escrito en inglés sencillo.
* Trae material de Youtube: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk
* [Let's get rusty](https://www.youtube.com/c/LetsGetRusty)
* Hay muchos youtubers subiendo contenido de Rust, pero este lo he disfrutado especialmente.
* Además ha estado subiendo las últimas noticias sobre Rust. Merece la pena suscribirse.
* [Rust for Linux](https://github.com/Rust-for-Linux)
* Mira el código de ejemplo y comprueba cómo Rust se introducirá en el núcleo Linux.
## <a name="Aplicaciones"></a>Aplicaciones
### <a name="Hardware-y-firmware"></a>Hardware y firmware
Si quieres ser un ingeniero embebido, será mejor empezar por un kit de hardware sencillo en lugar de con el último de ARM, por ejemplo.
* [Kit de iniciación de Arduino](https://www.arduino.cc)
* Hay muchas series de Arduino, pero su kit de iniciación (Start Kit) tiene un microprocesador muy simple (Atmega328P) y un libro guía.
* Atmega328P tiene un procesador de 8 bitsA que es un buen punto de partida para empezar a diseñar circuitos digitales y desarrollo de firmware.
* No necesitas saber dibujar esquemáticos ni diseños ni a soldar los chips.
* Pero sí necesitas saber cómo leer los esquemáticos y entender cómo están conectados los chips.
* Los desarrolladores de firmware deben ser capaces de leer los esquemáticos y averiguar cómo enviar datos al dispositivo que sea.
* ¡Sigue el libro guía!
* [Manual de 8086](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf)
* Si eres un principiante con la arquitectura x86, 8086 puede servir muy bien como guía para aprender ensamblador de 80x86.
* [Manual de 80386](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf)
* La mejor guía sobre el modo protegido y el mecanismo de paginación en procesadores 80x86.
* [Versión web](https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm)
Llegados a este punto podrías empezar con los últimos procesadores de ARM o x86:
* https://www.raspberrypi.org/
* https://beagleboard.org/
* https://www.arduino.cc/en/ArduinoCertified/IntelEdison
Por ejemplo, la placa Raspberry Pi tiene un Cortex-A53 y suporta un juego de instrucciones de 64 bits.
Esto permite que experimentes un procesador con arquitectura más moderna.
Sí, puedes comprarte una rPi, pero, ¿qué harás con ella?
Si no tienes un proyecto pensado, probablemente la rPi acabará en un cajón guardada y olvidada con los otros cachivaches.
Así que te recomiendo un proyecto:
* [Hacer tu propio núcleo](http://wiki.osdev.org/Getting_Started)
* Buenas referencias en [Reddit](https://www.reddit.com/r/osdev)
* [Aprendiendo desarrollo de sistemas operativos usando el núcleo Linux y Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
He hecho un [núcleo de juguete](https://github.com/gurugio/caos) que soporta el modo *long* de 64 bits, paginación y un cambio de contexto básico. Hacer un núcleo aficionado es una forma buena de entender las arquitecturas modernas y el control del hardware.
De hecho, es probable que tengas un procesador moderno con dispositivos hardware moderno.
¡Tu portátil! ¡Tu ordenador de escritorio! Ya tienes todo lo que necesitas para empezar.
No necesitas comprar nada más.
El emulador QEMU puede emularte los últimos procesadores de ARM y de Intel.
Así que todo lo que necesitas ya está al alcance de tu mano.
Hay muchos núcleos hechos por aficionados y documentos a los que acudir.
Tan solo instala QEMU y haz un núcleo pequñito que tan solo arranque, comience la paginación e imprima algunos mensajes.
Otros núcleos aficionados o de juguete:
* https://littleosbook.github.io/
* https://tuhdo.github.io/os01/
### <a name="Núcleo-Linux-y-controladores-de-dispositivos"></a>Núcleo Linux y controladores de dispositivos
No necesitas hacer un sistema operativo completo.
Únete a la comunidad Linux y participa en el desarrollo.
Algunos recursos acerca del núcleo Linux y el desarrollo de controladores de novato a experto.
* Libros: Lee los siguientes en orden
* [El diseño del sistema operativo Unix](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997)
* Los conceptos básicos de Unix se aplican en casi todos los sistemas operativos.
* Este libro es un muy buen punto de partida para aprender los conceptos clave de los sistemas operativos.
* [Linux Device Drivers (LDD)](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* Haz todos los ejemplos por ti mismo.
* [Desarrollo del núcleo Linux](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel)
* Entender el diseño del núcleo Linux.
* [Entendiendo el núcleo Linux](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* Lee este libro y el código de Linux en la versión 2.6 al mismo tiempo
* No empieces con la última versión, utiliza la 2.6.
* Utiliza QEMU y GDB para correr el núcleo línea a línea.
* [Depurar Linux con QEMU y GDB](http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu)
* https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md
* Utiliza busybox para hacer el sistema de ficheros más simple y que tome sólo un segundo el arrancarlo.
* https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md
* Otros recursos: recursos gratis que recomiendo
* [Linux device driver labs](https://linux-kernel-labs.github.io/)
* Guía práctica y ejercicios excelentes para hacer controladores de Linux con APIs esenciales del núcleo.
* Creo que este documento introduce casi todas las APIs esenciales de Linux.
* [The Eudyptula Challenge](http://eudyptula-challenge.org/)
* _Tristemente, este reto ya no acepta participantes porque ya no es retador_. La persona que mantiene el proyecto dijo que estaba planeando un nuevo formato. Esperemos que llegue pronto.
* Pero puedes encontrar los enunciados del reto con Google. Algunas personas ya subieron sus respuestas. Encuentra los enunciados, intenta resolverlos por ti mismo y luego compara tu solución con la de otros.
* Es como un profesor privado que te va guiando.
* Si no sabes bien qué hacer, este es un buen punto de partida también.
* [Aprendiendo desarrollo de sistemas operativos usando el núcleo Linux y Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* Este proyecto no está terminado todavía.
* Siempre pienso que hacer un núcleo similar a Linux es la mejor forma de entender Linux.
* [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv)
* Empieza con un ejemplo simple de controlador de dispositivo de bloques (Ramdisk) con modo multi-queue.
* Avanza hasta llegar a la capa de bloques (*block layer*).
* He terminado la traducción a inglés. Por favor, enviadme vuestra opinión.
* [Controlador md del núcleo Linux (coreano)](https://github.com/gurugio/book_linuxkernel_md)
* Cómo funciona la herramienta `mdadm` y cómo llama al controlador `md`.
* Cómo funciona el controlador `md`.
* [Código de Linux muy comentado](http://www.oldlinux.org/)
* Versión 0.12 de Linux con un montón de comentarios útiles.
* Puede ser bueno comenzar con un sistema operativo viejo y simple.
* Versión Unix: [Comentarios de Lion a la sexta edición de Unix, con código fuente](https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code)
### <a name="Referencias"></a>Referencias
Échales un ojo cuando necesites algo:
* [Página principal de Free-electrons](http://free-electrons.com/docs/)
* Muchas diapositivas/transparencias que introducen temas interesantes, especialmente ARM-Linux.
* [¡Puedes ser un Kernel Hacker! Post de Julia Evans](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/)
* Guía para empezar la programación de núcleos.
### <a name="Otras-aplicaciones"></a>Otras aplicaciones
Puede que no estés interesado en Linux o en el firmware. De ser así, puedes encontrar otros usos:
* Programación de sistemas y controladores para Windows.
* Seguridad
* Ingeniería inversa
No sé mucho acerca de estos usos. Por favor, enviadme cualquier información que sea para principiantes.
**Los núcleos y los controladores no son todo el mundo del bajo nivel.** Un uso también importante de la programación a bajo nivel es el almacenamiento definido por software (*sw-defined storage*) o los sistemas de ficheros distribuidos. Dar una descripción detallada de lo que son se sale del alcance de este documento, pero hay un curso excelente en el que se puede probar un sistema de ficheros distribuido simple:
* Curso: https://pdos.csail.mit.edu/archive/6.824-2012/
* Código de referencia: https://github.com/srned/yfs
## <a name="Futuro-del-bajo-nivel"></a>Futuro del bajo nivel
No sé qué deparará el futuro, pero me mantengo atento a Rust.
* https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/
Si tuviese una semana libre para pasarla solo, aprendería Rust.
Esto es porque es el último lenguaje en el que se pueden desarrollar controladores para Linux.
* https://github.com/tsgates/rust.ko
IoT es una tendencia nueva, así que merece la pena mirar qué S.O. se utiliza para IoT.
ARM, Samsung, y otras compañías tienen sus propios [sistemas operativos de tiempo real](https://es.wikipedia.org/wiki/Sistema_operativo_de_tiempo_real), pero lamentablemente muchos de ellos son de código cerrado.
La Fundación Linux tiene una solución: Zephyr
* [Zephyr](https://www.zephyrproject.org/)
Los servidores en la nube suele tener muchas capas. Por ejemplo, un S.O. anfitrión, un controlador KVM, un proceso QEMU, un S.O. huésped y el servicio de aplicación. Los contenedores se han desarrollado para aportar virtualización ligera. En el futuro cercano, un nuevo concepto de S.O llamado S.O. de librería o Unikernel podŕia reemplazar la pila típica de SW para virtualización.
* https://unikernel.org
El Big Data y la computación en la nube necesitan cada vez más y más almacenamiento. Algunos discos que están directamente dentro del servidor no pueden satisfacer la capacidad, estabilidad ni desempeño necesarios. Se ha investigado cómo hacer grandes sistemas de almacenamiento conectando muchos más pequeños a través de una red de alta velocidad. Solían estar enfocados en hacer un volumen de almacenamiento enorme, pero actualmente están dedicando varios volúmenes a las máquinas virtuales:
* `EN` https://en.wikipedia.org/wiki/Software-defined_storage
* `EN` https://en.wikipedia.org/wiki/Clustered_file_system
* https://es.wikipedia.org/wiki/Ceph_File_System
## <a name="Cómo-empezar"></a>Cómo empezar
Recibí un email preguntando cómo empezar. Hay mucha información sobre libros, cursos y proyectos en esta página. Es error mío olvidarme de escribir cómo empezar. Por desgracia, no hay una única forma de hacerlo. Me limitaré a escribir los pasos que yo di en orden. Si ya has hecho algo similar, por favor, sáltate ese paso. De nuevo, esto es SÓLO UN EJEMPLO de lo que podrías hacer en caso de que no sepas cómo empezar o qué hacer.
* Leer libros de teoría de sistemas operativos: al menos "El diseño del sistema operativo Unix" de Maurice J. Bach
* Aprender ensamblador y C
* [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086)
* Es suficiente si entiendes el concepto de programación en ensamblador. No hace falta que hagas algo práctico.
* [The C Programming Language 2nd Edition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* Intenta resolver todos los ejercicios por ti mismo, es importante.
* [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* Haz algo práctico con C
* [C Project Based Tutorials](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/): Encuentra un par de proyectos interesantes y haz el tuyo propio.
* [leetcode.com](https://leetcode.com/): Si no encuentras un proyecto interesante, está bien centrarte en estructuras de datos y algoritmos, siempre es buena práctica.
* Haz un proyecto hardware
* Raspberry Pi o Arduino, no importa. Necesitas experiencia para controlar el hardware directamente sólo con C. ¡SÓLO CON C!
* Recomiendo que te compres un kit del Atmega128 y que hagas firmware para encender y apagar LEDs, detectar el estado de un interruptor, mostrar mensajes en el LCD. Un proyecto que incluya algún motor es también interesante, como un robot que siga líneas en el suelo ([búscalo en Youtube](https://www.youtube.com/results?search_query=robot+sigue+lineas+arduino)).
* NO USES LIBRERÍAS. Deberías intentar hacerlo todo por ti mismo,
* Cosas básicas del núcleo Linux
* Deberías entender antes las entrañas del sistema operativo.
* Comienza con controladores
* Lee [Linux Device Drivers](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* [Linux device driver labs](https://linux-kernel-labs.github.io/)
* [The Eudyptula Challenge](http://eudyptula-challenge.org/)
* Lee [Linux Kernel Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel) para entender el funcionamiento interno de Linux.
* Ve al sector profesional
* Si quieres ser un desarrollador de Linux profesional
* Obligatorio: [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* Intenta hacer un núcleo de juguete
* [Aprende desarrollo de sistemas opeartivos con el núcleo Linux y Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* [Haz tu propio núcleo](http://wiki.osdev.org/Getting_Started)
* Pon un enlace a tu Github/Gitlab en tu CV (recuerda poner mensajes de commit claros).
* Mantente actualizado con lo publicado en https://lwn.net/ ¡y suscríbete!
* Comprueba los "Recent Kernel Patches" en https://lwn.net/Kernel/ o https://lwn.net/Kernel/Patches.
* Encuentra un parche interesante. Intenta entender el código. Por supuesto será muy difícil, pero inténtalo, fuérzate. Cada vez que lo intentes estarás más cerca.
* Compila el núcleo y pruébalo en tu sistema. Por ejemplo, hazle una prueba de rendimiento o de estabilidad con [LTP](https://linux-test-project.github.io/) o alguna herramienta de análisis estático del código dentro del núcleo.
* Notifica cualquier problema que te encuentres: errores o avisos de compilación, bajadas de rendimiento, kernel panic/oops o cualquier otro problema.
* Si funciona bien, notifícalo también junto a las especificaciones de tu sistema. El dueño del parche podrá escribir una etiqueta "Reviewed-by" con tu nombre.
* ¡Encuentra tu nombre en el `git log` del núcleo!
* O encuentra otros temas
* Hay muchos campos en los que puede trabajar un ingeniero a bajo nivel: seguridad, compiladores, firmware, industria robótica, automovilística, ferroviaria, militar, naval, aeroespacial, y un largo etcétera.
# <a name="Traducción"></a>Traducción
Por favor, mándame el Pull Request si te gustaría traducir esta página.
# <a name="Quién-soy"></a>Quién soy
Me inspiré en [google-interview-university](https://github.com/jwasham/coding-interview-university). Me gustaría compartir mi experiencia y mostrar un mapa de ruta para convertirse en un programador a bajo nivel porque he visto que estas habilidades ya no son tan comunes como fueron una vez. Además, muchos estudiantes y principiantes me preguntan cómo convertirse en programadores a bajo nivel e ingenieros del núcleo de Linux.
Para tu información, tengo más de 10 años de experiencia como programador a bajo nivel:
* Programación en ensamblador 80x86
* Dispositivos hardware y firmware con chips Atmel
* Programación de sistemas para Unix en C
* Controladore de dispositivos en Linux
* Núcleo Linux: paginación
* Núcleo Linux: Módulo `md` y controladores para dispositivos de bloques.
================================================
FILE: README_fa.md
================================================
<div dir="auto">
توجه: لطفا توجه داشته باشید که برنامه نویسی سطح پایین در حال حاضر متقاضیان زیادی نداشته و کمپانی های زیادی اقدام به استخدام برنامه نویس سطح پایین نمی کنند. برای من هم پیدا کردن شغلی در این رابطه همواره سخت تر میشود. به همین دلیل توصیه میکنم اگر هنوز فعالیت حرفهای خود را شروع نکردهاید، سایر زمینهها را نیز در نظر بگیرید.
- [دانشگاه برنامهنویسی سطح پایین]()
- [در چه مورد صحبت میکنیم؟]()
- [سطح پایین به چه معناست؟ ]()
- [تئوری]()
- [زبانها]()
- [اسمبلی]()
- [سی](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fa.md#سی)
- [اپلیکیشنها]()
- [سختافزار و ثابتافزار]()
- [هسته و درایور لینوکس]()
- [منابع]()
- [سایر اپلیکیشنها]()
- [آینده برنامهنویسی سطح پایین]()
- [چطور شروع کنیم؟]()
- [ترجمه]()
- [درباره مولف]()
دانشگاه برنامهنویسی سطح پایین:
-------------------------------------------------------
**در چه مورد صحبت میکنیم؟**
-------------------------------------------------------
در نگارش این مقاله از [google-interview-university ](https://github.com/jwasham/coding-interview-university) الهام گرفته شده است. مایل هستم تجارب خود در این زمینه را به اشتراک بگذارم و راه تبدیل شدن به یک برنامهنویس سطح پایین را نشان دهم، زیرا حس میکنم این مهارتها
بهاندازه گذشته متداول نیستند. بعلاوه بسیاری از دانشجویان سوالاتی درباره اینکه چگونه برنامهنویس سطح پایین یا مهندس هسته لینوکس شوند میپرسند.
این صفحه نمیتواند تمامی دورههای آموزشی، لینکها و کتابها را در بر بگیرد.
بعنوان مثال این صفحه آردوئینو را معرفی میکند ولی به بررسی جزئیات آردوئینو و سیستمهای نهفته نمیپردازد و خودتان باید اطلاعات بیشتری در این مورد بدست بیاورید. برای این کار، کلیدواژه "آردوئینو" را در اختیار دارید و بهکمک آن میتوانید شروع کنید. بنابراین گامهای بعدی احتمالا جستجوی واژه "آردوئینو" در گوگل، خرید یک کیت و انجام دادن کاری از سوی خودتان میباشند نه جمعآوری لینک و کتب رایگان. لطفا بخاطر داشته باشید که این صفحه تنها راهنمایی برای مبتدیان است.
برنامهنویسی سطح پایین بخشی از علوم کامپیوتر است.مطمئنا بهتر است در ابتدا تحصیلاتی در زمینه علوم کامپیوتر انجام شود.
- [مسیر تحصیل علوم کامپیوتر بصورت آزاد و خودآموز.](https://github.com/ossu/computer-science)
- سطح پایین به چه معناست؟
---------------------------------------------------------
من برنامهنویسی سطح پایین را برنامهنویسی که به ماشین خیلی نزدیک است و از زبانهای سطح پایین همچون سی و اسمبلی استفاده میکند تعریف میکنم. این با برنامهنویسی سطح بالا- که در اپلیکیشنهای فضای کاربر متداول است و از زبانهایی چون پایتون و جاوا استفاده میکند- متفاوت است.
- [ویکیپدیا-زبان برنامهنویسی سطح پایین](https://fa.wikipedia.org/wiki/%D8%B2%D8%A8%D8%A7%D9%86_%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D9%87%E2%80%8C%D9%86%D9%88%DB%8C%D8%B3%DB%8C_%D8%B3%D8%B7%D8%AD_%D9%BE%D8%A7%DB%8C%DB%8C%D9%86)
بلی برنامهنویسی سیستم مفهومی است مشابه برنامهنویسی سطح پایین. این صفحه طراحی سختافزار و توسعه ثابتافزار را در بر میگیرد، مفاهیمی که جزو مباحث برنامهنویسی سیستم نیستند.
- [ویکیپدیا-برنامهنویسی سیستم](https://fa.wikipedia.org/wiki/%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D9%87%E2%80%8C%D9%86%D9%88%DB%8C%D8%B3%DB%8C_%D8%B3%DB%8C%D8%B3%D8%AA%D9%85)
سرانجام، این صفحه موضوعاتی همچون اجزای سختافزاری و هسته لینوکس را
شامل میشود. این گستره وسیعی از لایههاست و یک مطلب یک صفحهای
نمیتواند جزئیات تمام این لایهها را پوشش دهد بنابراین این مطلب میکوشد تا
نقطه شروعی برای یادگیری برنامهنویسی سطح پایین باشد.
**تئوری**
-------------------------------------------------------------
دو تئوری زمینهای در مورد برنامهنویسی سطح پایین وجود دارند:
- معماری کامپیوتر
- سیستمهای عامل
فکر میکنم بهترین راه برای یادگیری تئوری شرکت در دورههای آموزشی است.
خواندن کتاب راه بدی نیست ولی نیازمند زمان و تلاش زیادی است. شما میتوانید کلاسهای خوب زیادی در دانشگاههای آنلاین پیدا کنید. بعنوان مثال Coursera.org و edx.org. فکر نمیکنم نیازی به گرفتن نمره الف داشته باشید، فقط تصویر کلی را متوجه شوید. با کسب تجربه بهتر و بهتر خواهید شد.
اجازه بدهید چند کتاب را که خواندهام به شما معرفی کنم. این کتابها معمولا در دانشگاهها بعنوان کتاب تکست استفاده میشوند. اگر این کتابها در کلاسهای دانشگاهتان تدریس نمیشوند، خواندن آنها خالی از لطف نخواهد بود.
- معماری کامپیوتر
- معماری کامپیوتر، چاپ پنجم: دیدگاه کمی
- سیستمهای کامپیوتری: از دید یک برنامهنویس
- سازماندهی و طراحی کامپیوتر، جلد چهارم: رابط سختافزار-نرمافزار
- سیستمهای عامل
- توضیح باغ جادویی: درون یونیکس، سیستم ۵، چاپ۴، طراحی یک سیستم باز
- طراحی سیستم عامل یونیکس
- سیستمهای عامل: اصول طراحی و اجزاء درونی توسط ویلیام استالینگ
- دورههای آموزشی:
- [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94)
لیست نامحدودی از کتابهای خوب وجود دارد. قصد ندارم بگوییم که باید کتابهای زیادی بخوانید . فقط یک کتاب را به دقت بخوانید. وقتی که یک تئوری را یاد گرفتید، کد مربوط به آن را اجرا کنید. اجرای یک چیز بهتر از یاد گرفتن صدها تئوریست.
**زبانها:**
---------------------------------------------------------------
**اسمبلی:**یک اسمبلی از میان x86 یا ARM انتخاب کنید. نیازی به دانستن هر دو نیست، در مجموع نیازی به دانستن زبان اسمبلی نیست بلکه هدف درک ساختار درونی پردازشگر و کامپیوتر است. بنابراین نیازی نیست که اسمبلی جدیدترین پردازشگر را یاد بگیرید.از بین ۸۰۸۶ و Corex-M یکی را انتخاب کنید.
- [اسمبلی ۸۰۸۶ با emu8086](https://github.com/gurugio/book_assembly_8086)
- مفاهیم پایهای پردازشگر و معماری کامپیوتر
- مفاهیم پایهای زبان سی
- [اسمبلی ۶۴ بیت(در حال ترجمه)](https://github.com/gurugio/book_assembly_64bit)
- مفاهیم پایهای پردازشگر مدرن و معماری کامپیوتر
- مفاهیم پایهای پیاده کردن و رفع اشکال کد سی
- نیاز به کمک برای ترجمه
- [یادگیری اسمبلی برای لینوکس-x64](https://github.com/0xAX/asm)
- اسمبلی ۶۴ بیت با NASM و اسمبلی روی خط با GCC
- [راهنمای معماری ARM ، چاپ دوم](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196)
- منبع کامل برنامهنویسی ARM
- سازماندهی و طراحی کامپیوتر
- [ورژن MIPS](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/)
- [ورژن ARM ](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/)
- [ورژن RISC-V](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757)
- کتابهای آکادمیکی که درباره نحوه کارکرد تمام اجزای کامپیوتر توضیح میدهند.
- با طرح جزئیات درباره مفاهیم مختلف تشکیل دهنده معماری کامپیوتر توضیح میدهند.
- این منابع برای کسانی که قصد دارند با جزئیات یک زبان اسمبلی خاص آشنا شوند مناسب نیستند.
- ورژنهای MIPS و ARM موضوعات مشابه را در قالب دو معماری مختلف پوشش میدهند.
- هر دو ورژن شامل مثالهایی در مورد x86 هستند.
**زبان سی:**
میانبری وجود ندارد. کل کتاب را خوانده و تمام تمرینات را حل کنید.
- [زبان سی: نگرشی نو، چاپ دوم](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
- [زبان برنامهنویسی سی، چاپ دوم](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
- [سی مدرن](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf)
- برای استاندارد جدید سی
- [آیا برنامهنویسی موازی سخت است؟ اگر بلی چه میتوان کرد؟](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)
- پیادهسازی همزمانسازی با سی
- ضروری برای سی در سطح کلان(خصوصا برای برنامهنویسی هسته)
- [دوره آموزشی سی بر پایه پروژه؟](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/)
- اگر یک یا دو کتاب درباره سی خواندید، باید کار عملی انجام دهید .
- چیزی را که دوست دارید انتخاب کنید.
-ابتدا کد خود را بنویسید و آنرا با کد کس دیگری مقایسه کنید. تنها زمانی میتوانید مهارتتان را بهبود ببخشید که کد سایرین را بخوانید و روشهای بهتری یاد بگیرید. کتابها ایستا هستند ولی کد همواره در حال تغییر است.
- [پروژههای مرتبط با سی و سایر زبانها](https://github.com/danistefanovic/build-your-own-x)
- پروژههای جذاب دیگری پیدا کنید.
-[کتاب سیاه برنامهنویسی گرافیکی میشل ابرش، چاپ ویژه](http://www.jagregory.com/abrash-black-book/)
- منبعی درباره بهینهسازی با استفاده از سی و مقداری اسمبلی.
- از اسمبلی ۸۰۸۸ تا کنون را در بر میگیرد.
- با تمرکز ویژه بر روی بهینهسازی گرافیکی سطح پایین.
- [طراحی افزایه و چارچوب در سی](https://github.com/gurugio/book_cprogramming)
- چگونه چارچوب و افزایه را با سی و در سطح وسیع گسترش دهیم؟
- نکاتی بسیار ابتدایی برای خواندن منبع هسته لینوکس.
اگر قصد دارید در سی تبحر پیدا کنید به سایت [https://leetcode.com/](https://leetcode.com/)مراجعه کنید.
**کاربردها**
-------------------------------------------------------------
**سختافزار و ثابتافزار:**
اگر میخواهید مهندس سیستمهای نهفته شوید شروع با یک کیت سختافزاری ساده گزینه بهتری از جدیدترین تراشه ARM است.
- [کیت آغازین آردوئینو](https://www.arduino.cc/)
- سریهای بسیاری از آردوئینو وجود دارند ولی کیت آغازین آردوئینو سادهترین پردازشگر(Atmega328P) را داشته و کتاب راهنما هم دارد.
- پردازشگر Atmega328P یک هسته هشت بیتی دارد که بستر مناسبی برای طراحی مدارهای دیجیتال و توسعه ثابتافزار فراهم میکند.
- نیازی به دانستن طراحی شماتیک و اسمبل کردن تراشه نیست.
- ولی باید بتوانید شماتیکها را خوانده و متوجه شوید تراشهها چگونه متصل میشوند.
- توسعهدهندگان ثابتافزار باید بتوانند شماتیکها را خوانده و بدانند چطور داده را به درایور مقصد بفرستند.
- کتب راهنما را دنبال کنید.
- [راهنمای ۸۰۸۶](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf)
- اگر در معماری 86× مبتدی هستید، ۸۰۸۶ نیز راهنمای خوبی برای معماری پردازشگر و اسمبلی ۸۶×۸۰ خواهد بود.
- [راهنمای ۸۰۳۸۶](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf)
- بهترین راهنما برای مدل محافظت شده و مکانیسم پردازشگر ۸۶×۸۰.
- ورژن وب:[https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm](https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm)
در این مرحله باید بقدری پیشرفت کرده باشید که بتوانید پردازشگرهای ARM یا 86× را شروع کنید.
- [https://www.raspberrypi.org/](https://www.raspberrypi.org/)
- [https://beagleboard.org/](https://beagleboard.org/)
- [https://www.arduino.cc/en/ArduinoCertified/IntelEdison](https://www.arduino.cc/en/ArduinoCertified/IntelEdison)
برای مثال بورد رسپبری پای پردازشگری با کورتکس-a53 دارد که مجموعه دستورات ۶۴ بیت را ساپورت میکند. این به شما امکان آشنا شدن با پردازشگر مدرن RPi را میدهد. شما میتوانید آنرا بخرید ولی میخواهید چه کاری با آن انجام دهید؟ اگر برنامه خاصی ندارید احتمالا آنرا همانند سایر وسایلی که احتمالا قبلا خریدهاید در کشو انداخته و فراموش خواهید کرد.
بنابراین من یک پروژه به شما پیشنهاد میکنم:
- [ساختن یک کرنل](http://wiki.osdev.org/Getting_Started)
- چند منبع خوب: [https://www.reddit.com/r/osdev/](https://www.reddit.com/r/osdev/)
- [یادگیری گسترش سیستم عامل با استفاده از هسته لینوکس و رسپبری پای](https://github.com/s-matyukevich/raspberry-pi-os)
- (توصیف پروژه): این منبع حاوی یک راهنمای گام به گام است که نحوه ساختن هسته یک سیستم عامل ساده را از ابتدا نشان میدهد. هر مبحث طوری طراحی شده است که نشان میدهد که یک کارکرد هسته در سیستم عامل RPi چطور پیاده میشود و سپس نحوه عمل همان کارکرد در هسته لینوکس را نشان میدهد.
من یک [ شبه هسته](https://github.com/gurugio/caos) ساختهام که مدل ۶۴ بیت، پیجینگ و جابجایی ساده موضوع را ساپورت میکند. ساختن چنین هستهای کمک میکند تا با معماری کامپیوترهای نوین و کنترل سختافزار آشنا شوید.
در واقع شما تا به اینجا جدیدترین پردازشگرها و سختافزار را بواسطه لپتاپ و دسکتاپتان در اختیار دارید. در حقیقت تمام چیزهای مورد نیاز برای شروع در دسترستان هستند و نیاز به خرید چیزی ندارید. برابرساز کمو میتواند برای پردازشگر ARM و اینتل برابرسازی کند. بنابراین تمام چیزهای مورد نیاز در اختیارتان هستند. هستهها و مطالب زیادی وجود دارند که شما میتوانید از آنها استفاده کنید. برابرساز کمو را نصب کرده و یک هسته کوچک که بوت میشود، صفحهبندی را فعال میکند و چند پیام را چاپ میکند بسازید.
سایر هستهها:
- [https://littleosbook.github.io/](https://littleosbook.github.io/)
- [https://littleosbook.github.io/](https://littleosbook.github.io/)
**هسته لینوکس و درایور**
نیازی به ساختن یک سیستم عامل کامل ندارید.به انجمن لینوکس پیوسته و در توسعه آن شرکت کنید.
منابعی برای هسته لینوکس و درایور از مبتدی تا پیشرفته،
- کتابها: این کتابها را بهترتیب بخوانید:
- [طراحی سیستم عامل لینوکس](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997)
- مفاهیم پایهای لینوکس در تمامی سیستمهای عامل استفاده میشوند.
- این کتاب منبع مناسبی برای درک مفاهیم بنیادی سیستمهای عامل است.
- [درایورهای لینوکس](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
- تمام مثالها را برای خودتان بسازید.
- [توسعه هسته لینوکس](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel)
- طراحی هسته لینوکس را درک کنید.
- [متوجه شدن هسته لینوکس](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
- این کتاب و منبع هسته V2.6 را بطور همزمان بخوانید.
- هیچگاه با آخرین ورژن شروع نکنید، V2.6 کافی است.
- برای اجرای خط به خط منبع هسته از کمو و جی دی بی استفاده کنید.
[http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu](http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu)
[https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md](https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md)
-از بیزیباکس برای ساختن سادهترین سیستم فایلبندی استفاده کنید که در مدت یک ثانیه بالا میآید.
- [https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md](https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md)
- سایر منابع:منابع رایگانی که توصیه میکنم:
- آزمایشگاه درایورهای لینوکس.
- راهنمای عملی و تمرینات عالی برای ساختن درایورهای لینوکس بههمراه ایپیآیهای ضروری هسته.
- [چالش یودوپتولا](http://eudyptula-challenge.org/)
- متاسفانه این چالش اعضای جدیدی نمیپذیرد، چون چالش جدیدی وجود ندارد. نگهدارنده سایت گفته است که در حال کار بر روی یک فرمت جدید است. امیدوارم که شاهد بازگشت این چالش باشیم.
- شما میتوانید سوالات مربوطه را در گوگل سرچ کنید. سعی کنید سوالات را حل کنید و پاسخ را با جوابهای موجود مقایسه کنید.
- این مشابه یک معلم خصوصی است که شما را راهنمایی میکند.
- اگر نمیدانید چه کنید این را شروع کنید.
- [یادگیری توسعه سیستم عامل با استفاده از هسته لینوکس و رسپبری پای](https://github.com/s-matyukevich/raspberry-pi-os)
- این پروژه هنوز کامل نشده است.
- همواره بر این عقیده هستم که ساختن هستهای مشابه هسته لینوکس بهترین راه برای یادگیری هسته لینوکس است.
- لایه بلاک و درایور دستگاه:
- از یک بلاک ساده درایور(مثلا رامدیسک) با مدل چند صفی شروع کنید.
- جلوتر رفته و به لایه بلاک بروید.
- ترجمه انگلیسی را تمام کردم، لطفا نظر خود را برایم بفرستید.
- [درایور امدی برای لینوکس(کرهای)](https://github.com/gurugio/book_linuxkernel_md)
- ابزار mdadm چطور کار میکند و چطور درایورmd را فرامیخواند؟
- درایور md چطور کار میکند؟
**منابع**
وقتی به چیزی نیاز دارید آنرا چک کنید.
- [صفحه الکترون آزاد](http://free-electrons.com/docs/)
- فایلهای اسلاید متعددی که موضوعات خوبی همچون لینوکس ARM را معرفی میکنند.
-[پست جولیا ایوان: شما میتوانید یک هکر هسته باشید](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/)
- راهنمایی برای برنامهنویسی هسته.
**سایر اپلیکیشنها**
شاید شما به لینوکس و ثابتافزار علاقه نداشته باشید. در اینصورت میتوانید
اپلیکیشنهای دیگری پیدا کنید:
- برنامهنویسی سیستمی و درایور لینوکس.
- ایمنی.
- مهندسی معکوس.
من درباره این اپلیکیشنها اطلاعی ندارم. لطفا هر نوع اطلاعات مبتدی در این زمینه دارید برایم بفرستید.
برنامهنویسی سطح پایین به هسته و درایورها محدود نمیشود. یکی دیگر از کاربردهای این نوع برنامهنویسی ذخیره نرمافزاری یا سیستم فایلبندی توزیع شده است.
- دوره آموزشی: [https://pdos.csail.mit.edu/archive/6.824-2012/](https://pdos.csail.mit.edu/archive/6.824-2012/)
- منبع: [ https://github.com/srned/yfs](https://github.com/srned/yfs)
**آینده برنامهنویسی سطح پایین**
--------------------------------------------------------------
درباره آینده چیزی نمیدانم ولی نگاهم را به راست(Rust) دوختهام.
- [https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/](https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/)
اگر یک هفته آزاد و تنها بودم، راست را یاد میگرفتم چون این تنها زبان جدیدیست که میتوانم با آن درایور لینوکس بسازم.
- [https://github.com/tsgates/rust.ko](https://github.com/tsgates/rust.ko)
یوت(IoT) شیوه جدیدی است, بنابراین میتوانید بررسی کنید که چه سیستمهای عاملی برای آن مناسب هستند.ARM، سامسونگ و برخی از کمپانیهای دیگر سیستمهای عامل بیدرنگ خود را دارند ولی متاسفانه بسیاری از آنها منبع بسته هستند. ولی بنیاد لینوکس یک راه حل دارد: زفیر.
- [https://www.zephyrproject.org/](https://www.zephyrproject.org/)
سرورهای ابری متداوال لایههای گوناگونی دارند؛ مثلا سیستم عامل میزبان، درایور KVM، پروسه کمو، سیستم عامل میهمان و سرویسهای اپلیکیشن. یک مخزن هم برای فراهم کردن مجازیسازی سبک ایجاد شده است. در آینده نزدیک مفهومی جدید از سیستم عامل، یک به اصطلاح سیستم عامل کتابخانهای یا تک هستهای جایگزین منبع نرمافزار برای مجازیسازی خواهد شد.
- [http://unikernel.org/](http://unikernel.org/)
دادههای بزرگ و رایانش ابری پیوسته نیاز به فضای ذخیرهسازی بزرگتری دارند. برخی از دیسکهایی که مستقیما به سرورها وصل هستند نمیتوانند پاسخگوی ظرفیت، ثبات و عملکرد مورد نیاز باشند. بنابراین تحقیقاتی برای ایجاد سیستمهای ذخیرهسازی بسیار بزرگ انجام شدهاند که ماشینهای ذخیرهسازی متعددی را توسط شبکه پرسرعت متصل میکنند. اینها در گذشته بر ساخت یک حجم ذخیره بسیار بزرگ متمرکز بودند ولی در حال حاضر حجمهای متعددی که به ماشینهای مجازی مختلفی اختصاص داده شدهاند فراهم شدهاند.
- [https://en.wikipedia.org/wiki/Software-defined_storage](https://en.wikipedia.org/wiki/Software-defined_storage)
- [https://en.wikipedia.org/wiki/Clustered_file_system](https://en.wikipedia.org/wiki/Clustered_file_system)
- [https://en.wikipedia.org/wiki/Ceph_(software)](https://en.wikipedia.org/wiki/Ceph_(software))
**چطور شروع کنیم؟**
----------------------------------------------------------
ایمیلی دریافت کردم که پرسیده بود چگونه شروع کنیم. در این صفحه اطلاعات زیادی درباره درباره کتابها، دورههای آموزشی و پروژهها وجود دارند. اشتباه من بود که توضیح درباره چگونه شروع کردن را فراموش کردم.متاسفانه هیچ راه آسانی برای رسیدن به [کینگلندینگ](https://gameofthrones.fandom.com/wiki/King%27s_Landing) وجود ندارد و من به توضیح اینکه خودم چگونه شروع کردم میپردازم. اگر تا کنون کاری انجام دادهاید لطفا از این بخش عبور کنید. این تنها مثالی است که به شما میآموزد که برای شروع چکار کنید.
- خواندن کتابهای سیستم عامل: حداقل کتاب *طراحی سیستم عامل لینوکس* نوشته موریس جی باخ را بخوانید.
- اسمبلی و سی را یاد بگیرید.
- [اسمبلی ۸۰۸۶ با امو ۸۰۸۶](https://github.com/gurugio/book_assembly_8086)
- یادگیری مفاهیم اسمبلی کافیست و نیازی به انجام کار عملی ندارید.
- [زبان برنامهنویسی سی، چاپ دوم](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
- سعی کنید که تمام تمرینات این کتاب را حل کنید.
- [برنامهنویسی سی، نگرشی نوین،چاپ دوم](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
- کاری عملی با سی انجام دهید.
-[خودآموزهای پروژهمحور سی](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/)
- یک یا دو پروژه جذاب انتخاب کنید و پروژه خودتان را بسازید.
-سایت[leetcode.com](https://leetcode.com/): اگر نمیتوانید پروژه مناسبی انتخاب کنید، ساختمان داده و الگوریتم میتوانند گزینههای مناسبی باشند.
- پروژهای در زمینه سختافزار انجام دهید.
- رسپبری پای و آردوئینو اهمیت چندانی ندارند. باید تجربه کنترل سختافزار با سی را داشته باشید، فقط با سی!
- توصیه میکنم یک کیتAtmega128 خریده و ثابتافزاری بسازید که السیدی ها را خاموش و روشن میکند. ورودی سوئچ و پیام نشان داده شده روی السیدی را ردیابی کنید. برنامه کنترل حرکت هم پروژه خوبی خواهد بود. بعنوان مثال ردیاب خط.
- از کتابخانه استفاده نکنید. باید همه چیز غیر از دانلود کننده برنامه را خودتان بسازید.
- مبانی هسته لینوکس.
- برنامهنویسی سطح پایین بسیار به سیستم عامل نزدیک است. باید با درون سیستم عامل آشنایی داشته باشید.
- با درایورها شروع کنید.
- [درایورهای لینوکس را بخوانید](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
-[آزمایشگاه درایورهای لینوکس](https://linux-kernel-labs.github.io/)
- [چالش یودوپتولا](http://eudyptula-challenge.org/)
- کتاب [توسعه هسته لینوکس](http://eudyptula-challenge.org/) را بخوانید.
- وارد زمینه حرفهای شوید.
- اگر میخواهید توسعه دهنده حرفهای هسته لینوکس شوید.
- باید کتاب[درک هسته لینوکس](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel
)
را بخوانید.
- سپس تلاش کنید یک شبه هسته بسازید.
- [یادگیری توسعه سیستم عامل با استفاده از هسته لینوکس و رسپبریپای](https://github.com/s-matyukevich/raspberry-pi-os)
- [هسته خودتان را بسازید](http://wiki.osdev.org/Getting_Started)
- به [https://lwn.net/](https://lwn.net/)بپیوندید و آخرین مسائل را دنبال کنید.
- یا موضوع دیگری پیدا کنید.
**ترجمه**
-------------------------------------------------------------
- اگر قصد ترجمه این صفحه را دارید، لطفا برایم تقاضا بفرستید. آن را به این لیست اضافه خواهم کرد.
- [Chinese(Traditional)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tw.md)
- [Chinese(Simplified)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md)
- [Portuguese (Brazilian)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md)
- [Italian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md)
- [Czech](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md)
- [Russian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md)
- [Turkish](https://github.com/masscollaborationlabs/lowlevelprogramming-university/blob/master/README_tr.md)
**درباره مولف**
---------------------------------------------------------
از مطلب [google-interview-university](https://github.com/jwasham/google-interview-university) الهام گرفتهام. تمایل دارم تجاربم را به اشتراک بگذارم و راه تبدیل شدن به یک برنامهنویس سطح پایین را نشان دهم زیرا دریافتهام که این مهارتها باندازه سابق محبوبیت ندارند. بعلاوه بسیاری از دانشجویان درباره اینکه چطور میتوان یک مهندس هسته لینوکس شد میپرسند.
من بیش از ده سال تجربه در زمینه برنامهنویسی سطح پایین دارم:
- اسمبلی ۸۶×۸۰
- سختافزار با تراشه و ثابتافزار Atmel
- برنامهنویسی سیستمی سی برای لینوکس
- درایور لینوکس
- هسته لینوکس: تخصیص صفحه
- هسته لینوکس: درایور بلاک و مودول امدی
</div>
================================================
FILE: README_fr.md
================================================
AVIS1: Veuillez ne pas copier le contenu de cette page sur votre blog. Vous pouvez partager cette page mais veuillez partager avec le lien d'origine. C'est ainsi que nous citons les auteurs de bons documents et de projets open source.
AVIS2: Veuillez noter que la programmation de bas niveau est hors de propos et qu'actuellement, il n'y a pas beaucoup d'entreprises qui embauchent des développeurs de bas niveau. Il devient de plus en plus difficile pour moi de trouver un emploi.
Si vous n'avez pas encore commencé une carrière professionnelle, je vous recommande de bien réfléchir avant de choisir ce domaine.
AVIS3: Si vous voulez un démarrage rapide, allez à "Comment démarrer ?".
* [Université de programmation de bas niveau](#Université-de-programmation-de-bas-niveau)
* [Qu'est-ce que c'est ?](#Qu'est-ce-que-c'est-?)
* [Qu'est-ce que le bas niveau ?](#Qu'est-ce-que-le-bas-niveau-?)
* [Théorie](#Théorie)
* [Langages](#Langages)
* [Assemblage](#Assemblage)
* [Langage C](#Langage-C)
* [Langage Rust](#Langage-Rust)
* [Applications](#Applications)
* [Matériel et micrologiciel](#Matériel-et-micrologiciel)
* [Linux noyau et pilote de périphérique](#Linux-noyau-et-pilote-de-périphérique)
* [Références](#References)
* [Autres applications](#Autres-applications)
* [L'avenir de la programmation de bas niveau](#L'avenir-de-la-programmation-de-bas-niveau)
* [Comment démarrer ?](#Comment-démarrer-?)
* [Traduction](#Traduction)
* [Qui suis-je ?](#qui-suis-je-?)
# Université de programmation de bas niveau
## <a name="Qu'est-ce-que-c'est-?"></a>Qu'est-ce que c'est ?
Je suis inspiré par [google-interview-university](https://github.com/jwasham/coding-interview-university). J'aimerais partager mon expérience et montrer une feuille de route pour devenir ingénieur en systèmes embarqués car j'ai constaté que ces compétences ne sont plus aussi courantes qu'avant. De plus, de nombreux étudiants et débutants me demandent comment ils pourraient devenir développeurs en systèmes embarqués et ingénieurs du noyau Linux.
Cette page ne peut pas inclure tous les liens/livres/cours. Par exemple, cette page présente Arduino mais il n'y a pas d'informations détaillées sur Arduino et les systèmes embarqués. Vous devriez aller plus loin par vous-même. Vous avez le mot-clé "Arduino" avec lequel vous pouvez commencer. Donc, votre prochaine étape est probablement de googler "Arduino", d'acheter un kit et de faire quelque chose par vous-même, pas de collecter des liens ou des livres gratuits. N'oubliez pas que cette page n'est qu'une feuille de route pour les débutants.
La programmation de bas niveau fait partie de l'informatique.
Absolument, il serait beaucoup mieux d'obtenir d'abord une éducation en informatique.
* `EN` [Chemin vers une éducation autodidacte gratuite en informatique !](https://github.com/ossu/computer-science)
## <a name="Qu'est-ce-que-le-bas-niveau-?"></a>Qu'est-ce que le bas niveau ?
Je classe la programmation de bas niveau comme une programmation très proche de la machine, en utilisant un langage de programmation de bas niveau comme C ou l'assembleur. Cela contraste avec la programmation de haut niveau, typique des applications utilisateur, utilisant des langages de haut niveau (par exemple Python, Java).
* `FR` [Wikipedia: Langage de programmation de bas niveau](https://fr.wikipedia.org/wiki/Langage_de_programmation_de_bas_niveau)
Oui, la programmation système est un concept très proche de la programmation de bas niveau. Cette page inclut la conception matérielle et le développement de micrologiciels qui ne sont pas inclus dans la programmation système.
* `EN` [Wikipédia: Programmation système](https://en.wikipedia.org/wiki/System_programming)
Enfin, cette page couvre des sujets allant des composants matériels au noyau Linux. C'est une énorme gamme de couches. Un document d'une page ne peut jamais couvrir les détails de toutes les couches, donc l'objectif de ce document est de servir de point de départ pour la programmation de bas niveau.
## <a name="Théorie"></a>Théorie
Il y a deux théories de fond pour la programmation de bas niveau:
* Architecture des ordinateurs
* Systèmes d'exploitation
Je pense que le meilleur moyen d'apprendre la théorie est de suivre un cours. Lire des livres n'est pas mal mais prend trop de temps et d'efforts. Vous pouvez trouver de nombreuses bonnes classes sur les universités en ligne, par exemple Coursera.org et edx.org.
La théorie est la théorie. Je ne pense pas que vous ayez besoin d'obtenir un A+ en classe, comprenez juste les grandes lignes.
Vous vous améliorerez de mieux en mieux avec l'expérience.
Je vous présenter plusieurs livres que j'ai lus. Ils sont couramment utilisés comme manuels dans les universités. S'il n'y a pas de classe avec ces livres dans votre université, il vaut la peine d'y consacrer un peu de temps.
* Livres sur l'Architecture d'ordinateurs
* `FR` Architecture des ordinateurs, cinquième édition: une approche quantitative
* `EN` Computer Systems: A Programmer's Perspective
* `EN` Computer Organization and Design, Fourth Edition: The Hardware/Software Interface
* Systèmes d'exploitation
* `EN` The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design
* `FR` La conception du système d'exploitation UNIX par Maurice Bach
* `EN` Operating Systems: Internals and Design Principles by William Stallings
* Cours recommandés
* `EN` [CS401: Operating Systems par saylor.org](https://learn.saylor.org/course/view.php?id=94)
* Compétences générales en programmation
* `EN` [Structure et interprétation des programmes informatiques](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs)
* C'est de la façon d'être un bon programmeur logiciel. Vous avez besoin non seulement de théorie mais aussi de techniques car la programmation est une sorte d'artisanat.
* Si vous apprenez Lisp/Scheme, vous devriez être capable d'apprendre rapidement n'importe quel autre langage.
* `EN` [J'ai résolu environ 80 % des exercices. Cela vaut la peine d'essayer chaque exercice unique.](https://github.com/gurugio/sicp_exercise)
* Conception de matériel
* Construisez votre propre kit de microprocesseur 8086
* Si vous ne construisez pas votre carte matériel, vous ne comprenez pas ce qu'est un périphérique mémoire mappé physiquement.
* Les AP modernes incluent tellement d'IPs. Donc, vous n'avez pas la chance de comprendre comment le noyau CPU et les périphériques sont connectés.
* Lorsque vous construisez votre propre kit 8086, vous avez la chance de localiser chaque périphérique sur la mémoire physique. Et vous pouvez définir comment les principaux composants de matériel (BUS, IRQ, horloge, alimentation, etc.) fonctionnent avec vos propres yeux.
* J'ai construit le kit 8086 dans mon université. C'était l'un des cours les plus précieux que j'ai jamais suivis. Essayez de construire votre propre kit de matériel. Ce serait mieux si le matériel est plus ancien et plus simple car vous devriez faire plus par vous-même.
* Google "kit 8086". Vous pourriez trouver certains sites Web où vous pouvez acheter un schéma matériel, des pièces et des manuels.
Il y a une liste infinie de bons livres. Je ne veux pas dire que vous devriez lire de nombreux livres. Il suffit de lire un livre avec soin. Chaque fois que vous apprenez une théorie, implémentez le code de simulation de celui-ci. **La mise en œuvre d'une chose vaut mieux que de connaître une centaine de théories.**
## <a name="Langages"></a>Langages
### <a name="Assemblage"></a>Assemblage
Choisissez entre de l'architecture x86 ou ARM. Pas besoin de connaître les deux. Peu importe de connaître le langage d'assemblage. L'essentiel est de comprendre les internes d'un processeur et d'un ordinateur. Vous n'avez donc pas besoin de pratiquer l'assemblage du dernier CPU. Sélectionnez 8086 ou Corex-M.
* `EN` [8086 Programmation d'assemblage avec EMU8086](https://github.com/gurugio/book_assembly_8086)
* Concepts de base de la processeur et de l'architecture informatique
* Concepts de base du langage de programmation C
* `EN` [64bit Assembly Programming (traduction en cours)](https://github.com/gurugio/book_assembly_64bit)
* Concepts de base du processeur moderne et de l'architecture informatique
* Concepts de base de désastre et de débogage du code C
* _Il y a de besoin d'aide à traduire._
* `EN` [Assemblage d'apprentissage pour Linux-x64](https://github.com/0xax/asm)
* Programmation d'assemblage 64 bits pure avec NASM et assemblage en ligne avec GCC
* `EN` [ARM Architecture Reference Manual, 2e édition](https://www.amazon.com/ARM-Architecture-Reference-Manual-2nd/dp/0201737191)
* Référence complète sur la programmation des bras
* Organisation et conception informatiques
* `EN` [Édition MIPS](https://www.amazon.ca/computer-organisation-design-mips-interface/dp/0124077269/)
* `EN` [Édition ARM](https://www.amazon.ca/computer-organisation-design-arm-interface/dp/0128017333/)
* `EN` [Édition RISC-V](https://www.amazon.com/computer-organisation-design-derish-vchitecture/dp/0128122757)
* Livres universitaires qui expliquent comment chaque composant d'un ordinateur fonctionne à partir de zéro.
* Explique en détail les différents concepts qui composent l'architecture informatique.
* Ils ne sont pas destinés aux lecteurs qui souhaitent devenir compétents dans un langage d'assemblage spécifique.
* L'édition MIPS et ARM couvre les mêmes sujets mais en disséquant une architecture différente.
* Les deux éditions contiennent des exemples dans le monde x86
### <a name="Langage-C"></a>Langage-C
Il n'y a pas de raccourci. Il suffit de lire tout le livre et de résoudre tous les exercices.
* `EN` [C Programming: A Modern Approach, 2e édition](https://www.amazon.com/c-programming-modern-approach-2nd/dp/0393979504)
* `EN` [The C Programming Language, 2e édition](https://www.amazon.com/programming-anguage-brian-w-kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=utf8&psc=1&refrid=60r1d2chba8dhyt6jnmn)
* Modern C: Jens Gustedt. Manning, 2019, 9781617295812. FFHAL-02383654F
* Pour une nouvelle norme de C
* `EN` [La programmation parallèle est-elle difficile et, si oui, que pouvez-vous faire à ce sujet?](Https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)
* Implémentation âpre de la synchronisation avec C
* Essentiel pour la programmation C à grande échelle (en particulier pour la programmation du noyau)
* `EN` [C Tutoriels basés sur le projet?](Https://www.reddit.com/r/c_programming/comments/872rlt/c_project_based_tutorials/)
* Si vous finissez de lire un ou deux livres de programmation C, il faut s'appliquez à quelque chose.
* Choisissez ce que vous voulez.
* Faites d'abord vous-même, puis comparez avec le code source de quelqu'un d'autre. Il est très important de comparer votre source et d'autres. Vous ne pouvez améliorer vos compétences que lorsque vous lisez le code source des autres et apprendre de meilleures méthodes. Les livres sont inflexible et le code source est en direct.
* `EN` [C et autres projets basés sur les langues](https://github.com/danistefanovic/build-your-own-x)
* Trouvez des projets plus intéressants
* `EN` [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/)
* Référence sur l'optimisation en utilisant C et un peu d'assemblage x86
* Commence du 8088 à aujourd'hui
* Focus spécial sur l'optimisation des graphiques de bas niveau
* `EN` [Framework and Plugin Design in C](https://github.com/gurugio/book_cprogramming)
* Comment développer le framework et le plugin en C pour les logiciels à grande échelle
* Conseils de programmation très basiques pour la lecture de le code source du noyau Linux
Si vous souhaitez être expert de la programmation C, visitez `EN` https://leetcode.com/. Bonne chance!
### <a name="Langage-Rust"></a>Rust
Je suis sûr que le prochain langage pour la programmation des systèmes serait Rust.
Je ferai une liste ce que j'ai fait pour apprendre Rust.
`EN` [Linus Torvalds a déclaré "Sauf quelque chose d'étrange, il arrivera en 6.1."](Https://www.zdnet.com/article/linus-torvalds-rust-will-go-into-linux-6-1/)
* `FR` [The Rust Programming Language](https://jimskapt.github.io/rust-book-fr/)
* Introduction excellente, mais il manque d'exemples et d'exercices.
* `EN` [Rust par l'exemple](https://doc.rust-lang.org/rust-by-example/)
* En lisant "The Rust Programming Language", vous pouvez trouver des exemples et des exercices ici.
* Mais il n'y a pas beaucoup d'exercices que vous pouvez faire quelque chose pour vous-même. Seuls quelques exemples comprennent des exercices «à faire» et ils sont très simples.
* `EN` [Programming Rust, 2e édition](https://www.oreilly.com/library/view/Programming-Rust-2nd/9781492052586/)
* Introduction plus profonde, mais toujours manque d'exemples et d'exercices.
* `EN` [Des Exercices](https://exercism.org/tracks/rust)
* De bons exercices pour pratiquer les caractéristiques indivisuelles de Rust.
* Je ne suis pas sûr que les mentors travaillent activement, mais ce serait suffisant pour comparer votre solution avec les autres.
* Après avoir soumis votre solution, vous pouvez voir les solutions des autres avec l'onglet "Solutions communautaires" (depuis l'exercice v3).
* De nombreux exercices de niveau facile sont destinés aux fonctionnalités utilitaires telles que la carte / filtre / tout et etc.
* `EN` [Rust Easy](https://dhghomon.github.io/easy_rust/)
* Un livre écrit en anglais simple.
* Leçons YouTube fourni: https://www.youtube.com/playlist?list=plfllocyhvgsrwlktahg0e-2qxcf-ozbkkk
* `EN` [Let's Get Rusty](https://www.youtube.com/c/letsgetrusty)
* Il y a beaucoup de YouTubers à télécharger le cours de Rust, mais j'ai le plus apprécié ce cours.
* Il a téléchargé les dernières nouvelles pour Rust. Il vaut la peine de s'abonner.
* `EN` [Rust en Linux](https://github.com/rust-for-linux)
* Voir l'exemple de sources et vérifier comment Rust va entrer dans le noyau Linux
## <a name="Applications"></a>Applications
### <a name="Matériel-et-micrologiciel"></a>Matériel & Micrologiciel
Si vous voulez être ingénieur en systèmes embarqués, il serait préférable de commencer par un simple kit matériel, plutôt que de commencer avec le dernier jeu de puces ARM.
* `EN` [Kit de démarrage Arduino](https://www.arduino.cc/)
* Il existe de nombreuses séries d'Arduinos mais le "Kit de démarrage Arduino" a le processeur le plus simple (Atmega328P) et le livre de guide
* L'Atmega328P a un cœur 8 bits qui est un bon endroit pour commencer la conception de circuits numériques et le développement de microprogrammes.
* Vous n'avez pas besoin de savoir comment dessiner des schémas et des plans et assembler les puces.
* Mais vous devez savoir comment lire les schémas et comprendre comment les puces sont connectées.
* Les développeurs de micrologiciels doivent être capables de lire les schémas et de comprendre comment envoyer des données au périphérique cible.
* Suivez le guide !
* `EN` [Manuel 8086](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf)
* Si vous débutez dans l'architecture x86, le 8086 est également un très bon guide pour l'architecture du processeur et l'assemblage 80x86.
* `EN` [Manuel 80386](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf)
* Meilleur guide pour le mode protégé et le mécanisme de pagination du processeur 80x86
* Version Web: `EN` https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm
À ce stade, vous devriez être en mesure de commencer le dernier processeur ARM ou x86.
* `EN` https://www.raspberrypi.org/
* `EN` https://beagleboard.org/
* `EN` https://www.arduino.cc/en/ArduinoCertified/IntelEdison
Par exemple, la carte Raspberry Pi (rPi) possède un processeur Cortex-A53 qui prend en charge un jeu d'instructions 64 bits.
Cela vous permet de découvrir une architecture de processeur moderne avec rPi.
Oui, vous pouvez l'acheter... mais... qu'allez-vous en faire ?
Si vous n'avez pas de projet cible, vous seriez susceptible de jeter le matériel dans un tiroir et de l'oublier comme les autres gadgets que vous avez peut-être achetés auparavant.
Donc, je vous recommande un projet pour vous.
* [Faire votre propre noyau](http://wiki.osdev.org/getting_started)
* Bonnes références: https://www.reddit.com/r/osdev/
* [Développement du système d'exploitation d'apprentissage à l'aide du noyau Linux et de Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* (Description du projet) Ce référentiel contient un guide étape par étape qui enseigne comment créer un simple noyau de système d'exploitation (OS) à partir de zéro ... (skip) ... chaque leçon est conçue de telle manière que Il explique d'abord comment certaines fonctionnalités du noyau sont implémentées dans le rPi OS, puis il essaie de démontrer comment la même fonctionnalité fonctionne dans le noyau Linux.
J'ai fait [un petit noyau](https://github.com/gurugio/caos) qui prend en charge le mode long 64 bits, la pagination et la commutation de contexte très simple. Faire un petit noyau est un bon moyen de comprendre l'architecture informatique moderne et le contrôle du matériel.
En fait, vous avez déjà le dernier processeur et les derniers appareils matériels.
Ton ordinateur portable! Votre bureau! Vous avez déjà tout ce dont vous avez besoin pour commencer!
Vous n'avez rien à acheter.
L'émulateur Qemu peut imiter les derniers processeurs ARM et processeurs Intel.
Donc, tout ce dont vous avez besoin est déjà à portée de main.
Il existe de nombreux grains de jouets et documents auxquels vous pouvez vous référer.
Installez simplement l'émulateur Qemu et faites un minuscule noyau qui bottise, allume la pagination et imprime certains messages.
Des autres petites noyau:
* https://littleosbook.github.io/
* https://tuhdo.github.io/os01
### <a name="Linux-noyau-et-pilote-de-périphérique"></a>Linux noyau et pilote de périphérique
Vous n'avez pas besoin de faire un système d'exploitation complet. Rejoignez la communauté Linux et participez au développement.
Quelques ressources pour le développement de pilotes de périphériques et de noyaux Linux, du débutant à l'avancé.
* Livres: Lisez ce qui suit dans l'ordre
* `EN` [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997)
* Les concepts de base d'Unix sont appliqués à tous les systèmes d'exploitation.
* Ce livre est un très bon resource pour apprendre les concepts de base des systèmes d'exploitation.
* `EN` [Linux Device Drivers](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* Faites tous les exemples par vous-même
* `EN` [Linux Kernel Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel)
* Comprendre la conception du noyau Linux
* `EN` [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* Lisez ce livre et le code source du noyau v2.6 en même temps
* Ne commencez jamais par la dernière version, v2.6 est suffisant !
* Utilisez qemu et gdb pour exécuter le code source du noyau ligne par ligne
* `EN` http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu
* `EN` https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md
* Utilisez busybox pour créer le système de fichiers le plus simple qui ne prend qu'une seconde pour démarrer
* `EN` https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md
* Autres ressources: ressources gratuites que je recommande
* `EN` [Linux device driver labs](https://linux-kernel-labs.github.io/)
* Guide pratique et excellents exercices de création de pilotes de périphériques Linux avec les API de noyau essentielles
* Je pense que ce document présente presque toutes les API de noyau essentielles.
* `EN` [Le défi Eudyptula](http://eudyptula-challenge.org/)
* _Malheureusement, ce défi n'accepte plus de nouveaux challengers car il n'y a plus de défi._ Le mainteneur a dit qu'il prévoyait un nouveau format. J'espère qu'il reviendra dès que possible.
* Mais vous pouvez trouver les questions du défi avec Google. Certaines personnes ont déjà téléchargé ce qu'elles ont fait. Trouvez les questions et essayez de les résoudre par vous-même, puis comparez votre solution avec celles des autres.
* C'est comme un excellent professeur privé qui vous guide sur ce qu'il faut faire.
* Si vous ne savez pas quoi faire, commencez simplement par cela.
* `EN` [Apprendre le développement de systèmes d'exploitation à l'aide du noyau Linux et du Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* Ce projet n'est pas encore terminé.
* Je pense toujours que créer un noyau similaire au noyau Linux est le meilleur moyen de comprendre le noyau Linux.
* `EN` [Couche de bloc et pilote de périphérique](https://github.com/gurugio/book_linuxkernel_blockdrv)
* commencez par un exemple simple de pilote de périphérique de bloc (ramdisk) avec le mode multi-files d'attente
* allez de l'avant vers la couche de bloc
* J'ai terminé la traduction en anglais. Envoyez-moi vos commentaires.
* `KO` [Pilote md du noyau Linux (coréen)](https://github.com/gurugio/book_linuxkernel_md)
* comment l'outil mdadm fonctionne et comment il appelle le pilote md
* comment fonctionne le pilote md
* `EN` [Un code source de noyau Linux lourdement commémoré](http://www.oldlinux.org/)
* Commentaires profonds pour l'ancien Linux v0.12.
* Il serait bon de commencer par un OS ancien et simple.
* Version Unix: `EN` [Commentaire de Lions sur UNIX 6e édition, avec code source](https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code)
#### <a name="Références"></a>Références
Vérifiez lorsque vous avez besoin de quelque chose
* `EN` [Page d'accueil bootlin](https://bootlin.com/docs/)
* de nombreux fichiers de diapositives présentant de bons sujets, spécialement ARM-linux
* `EN` [Publication de Julia Evans: Vous pouvez être un hacker de noyau !](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/)
* guide pour commencer la programmation de noyau
### <a name="Autres-applications"></a>Autres applications
Oui, vous n'êtes peut-être pas intéressé par Linux ou le micrologiciel. Si tel est le cas, vous pouvez trouver d'autres applications:
* Programmation de systèmes Windows et pilotes de périphériques
* Sécurité
* Rétro-ingénierie
Je n'ai aucune connaissance sur ces applications. Veuillez m'envoyer toute information pour les débutants.
**Les noyaux et les pilotes ne sont pas toute la programmation de bas niveau.** Une autre application importante de la programmation de bas niveau est le stockage défini par logiciel ou le système de fichiers distribué. La description détaillée de ceux-ci dépasse le cadre de ce document, mais il existe un excellent cours où vous pouvez essayer un simple système de fichiers distribué.
* Cours: `EN` https://pdos.csail.mit.edu/archive/6.824-2012/
* Source de référence: `EN` https://github.com/srned/yfs
## <a name="L'avenir-de-la-programmation-de-bas-niveau"></a>L'avenir de la programmation de bas niveau
Je ne connais pas l'avenir, mais je tiens Rust en compte.
* `EN` https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/
Si je pouvais avoir une semaine de libre et seul, j'apprendrais Rust.
C'est parce que Rust est le dernier langage avec lequel je peux développer des pilotes de périphériques Linux.
* `EN` https://github.com/tsgates/rust.ko
L'IdO est une nouvelle tendance, il vaut donc la peine de vérifier quels sont les systèmes d'exploitation pour l'IdO.
ARM, Samsung et certaines entreprises ont leur propre système d'exploitation en temps réel mais malheureusement beaucoup d'entre eux sont à code propriétaire (source fermé).
Mais la Fondation Linux a également une solution: Zephyr
* `EN` https://www.zephyrproject.org/
Les serveurs cloud typiques ont de nombreuses couches ; par exemple, le système d'exploitation hôte, le pilote kvm, le processus qemu, le système d'exploitation guest et l'application de service. Un conteneur a été développé pour fournir une virtualisation légère. Dans un avenir proche, un nouveau concept de système d'exploitation, un soi-disant système d'exploitation de bibliothèque ou Unikernel, remplacerait la pile logicielle typique pour la virtualisation.
* `EN` http://unikernel.org/
Le Big Data et le cloud computing nécessitent un stockage de plus en plus important. Certains disques connectés directement aux machines serveurs ne peuvent pas satisfaire la capacité, la stabilité et les performances requises. Par conséquent, des recherches ont été menées pour créer d'énormes systèmes de stockage avec de nombreuses machines de stockage connectées par un réseau haut débit. L'objectif était de créer un énorme volume de stockage. Mais actuellement, ils fournissent de nombreux volumes dédiés à de nombreuses machines virtuelles.
* `EN` https://en.wikipedia.org/wiki/Software-defined_storage
* `EN` https://en.wikipedia.org/wiki/Clustered_file_system
* `EN` https://en.wikipedia.org/wiki/Ceph_(software)
## <a name="Comment-démarrer-?"></a>Comment démarrer ?
J'ai reçu un e-mail me demandant comment démarrer. Il y a pleine d'informations sur les livres, les cours et les projets dans cette page. C'est mon erreur d'avoir oublié d'écrire comment démarrer. Malheureusement, il n'y a pas de route royale vers `EN` [King's Landing](https://gameofthrones.fandom.com/wiki/King%27s_Landing). Je vais simplement écrire ce que j'ai fait dans l'ordre. Si vous avez déjà fait quelque chose, veuillez le ignorer. Tiens en compte, c'est juste un exemple que vous pouvez suivre dans l'ordre, au cas où vous ne sauriez pas comment démarrer ou quoi faire.
* Lire les livres de théorie des systèmes d'exploitation: au moins "The Design of the UNIX Operating System" par Maurice J. Bach
* Apprendre l'assemblage et C
* `EN` [Programmation en assembleur 8086 avec emu8086](https://github.com/gurugio/book_assembly_8086)
* Il suffit de comprendre le concept de la programmation en assembleur. Vous n'avez pas besoin de faire quelque chose de pratique.
* `EN` [The C Programming Language, 2e édition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* FAITES DE VOTRE MIEUX pour résoudre chaque exercice !
* `EN` [C Programming: A Modern Approach, 2e édition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* Faites quelque chose de pratique avec C
* `EN` [Tutoriels de projet basés sur C ?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/): trouvez un ou deux projets intéressants et faites votre propre projet.
* `EN` [leetcode.com](https://leetcode.com/): Si vous ne trouvez pas de projet intéressant, il serait également bon de vous concentrer sur la structure de données et les algorithmes.
* Faire un projet matériel
* Choisissez Raspberrypi ou Arduino, peu importe lequel. Vous avez besoin d'expérience pour contrôler un matériel directement avec seulement C. UNIQUEMENT C !
* Je vous recommande d'acheter un kit Atmega128 et de créer un micrologiciel pour allumer/éteindre des LED, détecter l'entrée d'un commutateur et afficher un message sur l'écran LCD texte. Le programme de contrôle de moteur est également un très bon projet: par exemple, le traceur de ligne.
* N'UTILISEZ AUCUNE bibliothèque. Vous devez tout faire par vous-même, sauf le téléchargeur de programme.
* Notions de base du noyau Linux
* La programmation de bas niveau est très proche du système d'exploitation. Vous devez connaître l'intérieur du système d'exploitation.
* Commencez avec les pilotes
* Lisez `EN` [Pilotes de périphériques Linux](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* `EN` [Linux device driver labs](https://linux-kernel-labs.github.io/)
* `EN` [Le défi Eudyptula](http://eudyptula-challenge.org/)
* Lisez `EN` [Linux Kernel Driver Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel) pour comprendre l'interne du noyau Linux.
* Aller dans le domaine professionnel
* Si vous souhaitez devenir développeur professionnel de noyaux Linux
* doit lire `EN` [Comprendre le noyau Linux](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+noyau)
* Essayez ensuite de créer un noyau petit
* `EN` [Apprendre le développement de systèmes d'exploitation à l'aide du noyau Linux et du Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* `EN` [Créer votre propre noyau](http://wiki.osdev.org/Getting_Started)
* Écrivez le lien github vers votre noyau sur votre CV (n'oubliez pas d'écrire la description détaillée dans le message de validation)
* Consultez les derniers problèmes sur `EN` https://lwn.net/ et rejoignez-le.
* Consultez les "Correctifs de noyau récents" à `EN` "https://lwn.net/Kernel/" ou le lien direct `EN` https://lwn.net/Kernel/Patches
* Trouvez un correctif qui vous intéresse. Essayez de comprendre le code source. Bien sûr, ce sera vraiment difficile, mais essayez. Vous vous rapprocherez de plus en plus à chaque fois que vous essayerez.
* Générez le noyau et testez-le sur votre système. Par exemple, test de performances, test de stabilité avec LTP (`EN` https://linux-test-project.github.io/) ou outils d'analyse de code statique à l'intérieur du noyau.
* Signalez tout problème si vous en trouvez: avertissements/erreurs de compilation, dégradation des performances, panique du noyau/oops ou tout autre problème
* Si cela fonctionne bien, rapportez-le avec les spécifications de votre système. Le propriétaire du correctif écrira une balise "Reviewed-by" avec votre nom.
* Trouvez votre nom dans le journal git du noyau
* Ou trouvez d'autres sujets
* Il existe de nombreuses spécialités où l'ingénieur de bas niveau peut travailler: sécurité, compilateur, micrologiciel, robot / voiture, etc.
# <a name="Traduction"></a>Traduction
Veuillez m'envoyer une pull request si vous souhaitez traduire cette page. Je la répertorierai ici.
# <a name="qui-suis-je"></a>Qui suis-je ?
Je suis inspiré par [google-interview-university](https://github.com/jwasham/google-interview-university). J'aimerais partager mon expérience et montrer une feuille de route pour devenir ingénieur(e) en systèmes embarqués car j'ai constaté que ces compétences ne sont plus aussi courantes qu'avant. De plus, de nombreux étudiants et débutants me demandent comment ils pourraient devenir programmeurs de bas niveau et ingénieurs de noyaux Linux.
Pour votre information, j'ai plus de 10 ans d'expérience en tant que ingénieur en systèmes embarqués:
* Programmation en assembleur 80x86
* Périphérique matériel avec puce Atmel et micrologiciel
* Programmation système en langage C pour Unix
* Pilote de périphérique dans Linux
* Noyau Linux: allocation de pages
* Noyau Linux: pilote de périphérique de bloc et module md
================================================
FILE: README_id.md
================================================
CATATAN1: Mohon untuk tidak menyalin konten pada halaman ini untuk blog anda. Anda bisa membagikan halaman ini tapi mohon untuk menyertakan link asli. Itu adalah cara kita untuk mengapresiasi penulis dari proyek-proyek dokumentasi dan open source yang baik.
CATATAN2: Mohon untuk dicatat bahwa pemrograman tingkat rendah sudah ketinggalan zaman dan saat ini tidak banyak perusahaan yang mempekerjakan pengembang bahasa tingkat rendah. Dari hari ke hari semakin sulit untuk saya mencari pekerjaan di bidang ini. Jika anda masih belum memulai karir profesional, saya ingin menyarankan Anda mempertimbangkan bidang lain dengan hati-hati.
CATATAN3: Jika anda ingin langsung mulai, silahkan ke bagian "How to start?".
* [Low-Level Programming University](#Low-Level-Programming-University)
* [Apa itu?](#What-is-it)
* [Apa yang dimaksud dengan Low-Level?](#What-Is-the-Low-Level)
* [Teori](#Theory)
* [Bahasa](#Languages)
* [Assembly](#Assembly)
* [Bahasa C](#C-language)
* [Bahasa Rust](#Rust-language)
* [Pengaplikasian](#Applications)
* [Perangkat Keras && Firmware](#Hardware-Firmware)
* [Linux kernel and device driver](#Linux-kernel-and-device-driver)
* [Referensi](#References)
* [Pengaplikasian lain](#Other-applications)
* [Masa depan pemrograman tingkat rendah](#Future-of-low-level-programming)
* [Cara memulai?](#How-to-start)
* [Terjemahan](#Translation)
* [Tentang Saya?](#who-am-i)
# Low-Level Programming University
## <a name="What-is-it"></a>Apa itu?
Saya terinspirasi oleh [google-interview-university](https://github.com/jwasham/coding-interview-university). Saya ingin membagikan pengalaman dan menunjukkan roadmap untuk menjadi programmer low-level karena saya menemukan bahwa keterampilan ini tidak lagi umum seperti dulu. Selain itu, banyak pelajar dan pemula bertanya kepada saya bagaimana mereka bisa menjadi programmer low-level dan Linux kernel engineers.
Halaman ini tidak bisa menyertakan setiap tautan/buku/course. Contohnya, halaman ini memperkenalkan Arduino walaupun tidak ada informasi mendetil tentang Arduino dan sistem tertanam. Anda harus mengeksplorasinya sendiri.Anda sudah memiliki kata kunci "Arduino" sehingga anda bisa langsung memulai untuk mengeksplorasinya. Jadi untuk langkah selanjutnya adalah mungkin bisa mulai dengan "googling" tentang Arduino, membeli satu set alatnya, dan membuat sesuatu untuk diri anda sendiri, bukan mengumpulkan tautan-tautan dan buku-buku gratis. Mohon untuk diingat bahwa halaman ini hanyalah sebuah roadmap untuk pemula.
Pemrograman Low-level adalah bagian dari ilmu komputer.
Tentu saja akan lebih baik untuk memperoleh edukasi di ilmu komputer terlebih dahulu.
* [Jalan menuju pendidikan otodidak gratis di bidang Ilmu Komputer!](https://github.com/ossu/computer-science)
## <a name="What-Is-the-Low-Level"></a>Apa yang dimaksud dengan Low-Level?
Saya mengelompokkan pemrograman low-level sebagai pemrogaman yang sangat dekat ke mesin, menggunakan sebuah bahasa tingkat yang lebih rendah seperti C atau Assembly. Ini berlawanan dengan bahasa pemrograman yang lebih tinggi, seperti aplikasi pengguna pada umumnya, menggunakan bahasa tingkat tinggi (contoh: Python, Java).
* [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language)
Ya, pemrograman sistem adalah sebuah konsep yang sangat dekat dengan pemrograman low-level. Halaman ini berisi tentang perancangan perangkat keras dan pengembangan firmware yang tidak termasuk dalam pemrograman sistem.
* [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming)
Terakhir, halaman ini mencakup topik mulai dari komponen perangkat keras hingga kernel Linux. Itu adalah cakupan lapisan yang sangat banyak. Satu halaman dokumen tidak akan pernah cukup untuk mencakup detil-detil dari semua lapisan, jadi tujuan dari dokumen ini adalah sebagai titik mula untuk pemrograman low-level.
## <a name="Theory"></a>Teori
Ada dua latar belakang teori pada pemrograman low-level:
* Arsitektur Komputer
* Sistem Operasi
Menurut saya cara terbaik untuk belajar teori adalah dengan mengikuti course. Membaca buku bukan hal yang jelek juga, tetapi terlalu memakan banyak waktu dan tenaga. Anda bisa menemukan banyak kelas-kelas bagus pada kuliah online, contohnya, Coursera.org dan edx.org. Teori hanyalah teori. Saya tidak berpikir anda perlu dapat nilai A+ di kelas, cukup mengerti secara garis besar saja. Anda akan semakin baik seiring dengan pengalaman.
Izinkan saya untuk memperkenalkan buku-buku yang pernah saya baca. Secara umum digunakan sebagai buku teks di universitas-unversitas. Jika tidak ada buku-buku tersebut di universitas anda, dianjurkan untuk meluangkan waktu anda untuk membacanya.
* Arsitektur Komputer
* Computer Architecture, Fifth Edition: A Quantitative Approach
* Computer Systems: A Programmer's Perspective
* Computer Organization and Design, Fourth Edition: The Hardware/Software Interface
* Sistem Operasi
* The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design
* The Design of the UNIX Operating System
* Operating Systems: Internals and Design Principles by William Stallings
* Course yang Direkomendasikan
* [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94)
* Keterampilan Pemrograman Umum
* [Structure and Interpretation of Computer Programs](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs)
* Berisi tentang bagaimana cara menjadi pemrograman perangkat lunak yang baik. Anda bukan hanya butuh teori tapi juga teknik karena pemrograman adalah hal semacam kerajinan tangan (craftworks).
* Jika anda mempelajari Lisp/Scheme, anda seharusnya sudah bisa belajar bahasa lain dengan cepat.
* [Saya telah menyelesaikan sekitar 80% latihan. Dianjurkan untuk mencoba setiap latihan yang ada](https://github.com/gurugio/sicp_exercise)
* Perancangan Perangkat Keras
* Membangun 8086 Microprocessor Kit Anda Sendiri
* Jika anda tidak membangun papan HW (Hardware) anda sendiri, anda tidak memahami apa itu perangkat yang dipetakan memori fisik.
* AP modern memuat banyak sekali IP. Jadi anda tidak memiliki kesempatan untuk memahami bagaimana inti CPU dan perangkat periferal dihubungkan.
* Saat anda membangun 8086 kit anda sendiri, anda memiliki kesempatan untuk menempatkan tiap perangkat-perangkat periferal pada memori fisik. Dan anda sekarang bisa atur bagaimana komponen HW utama (BUS, IRQ, Clock, Power, dan lain-lain) bekerja dengan mata Anda sendiri.
* Saya membangun 8086 kit di universitas. Itu adalah salah satu course yang paling berharga yang pernah saya ambil. Cobalah untuk membangun HW kit anda sendiri. Akan lebih baik jika perangkat kerasnya lebih tua dan lebih simple karena anda harus melakukan hal lebih extra untuk anda sendiri.
* Coba ketik di Google "8086 kit". Anda seharusnya akan bisa menemuan beberapa situs web dimana anda bisa membeli sebuah skema HW, parts, dah panduannya.
Ada banyak daftar buku-buku yang bagus. Saya tidak menyebutkan anda harus baca banyak buku. Cukup baca satu buku dengan teliti. Kapanpun anda belajar sebuah teori, implementasikan kode simulasinya. **Mengimplementasikan satu hal lebih baik daripada mengetahui seratus teori**
## <a name="Languages"></a>Bahasa
### <a name="Assembly"></a>Assembly
Pilih satu antara x86 atau ARM. Tidak perlu untuk tau keduanya. Tidak mengetahui bahasa assembly juga tidak masalah. Hal yang mendasar adalah memahami bagian internal dari sebuah CPU dan komputer. Jadi anda tidak perlu mempraktikkan assembly dari CPU terbaru. Pilih 8086 atau Corex-M.
* [8086 pemrograman assembly dengan emu8068](https://github.com/gurugio/book_assembly_8086)
* konsep-konsep dasar CPU dan arsitektur komputer
* konsep-konsep dasar bahasa pemrograman C
* [pemrograman assembly 64bit (terjemahan sedang dalam pengerjaan)](https://github.com/gurugio/book_assembly_64bit)
* konsep-konsep dasar CPU modern dan arsitektur komputer
* konsep-konsep dasar pembongkaran dan debugging kode C
* _perlu bantuan untuk penterjemahan_
* [Belajar assembly untuk linux-x64](https://github.com/0xAX/asm)
* pemrograman assembly 64-bit murni dengan NASM dan inline assembly dengan GCC
* [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196)
* Referensi lengkap pada pemrograman ARM
* Organisasi dan Perancangan Komputer
* [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/)
* [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/)
* [RISC-V Edition](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757)
* Buku-buku akademis yang menjelaskan bagaimana tiap komponen dari sebuah komputer bekerja dari awal.
* Penjelasan detil perbedaan konsep-konsep yang membentuk arsitektur komputer.
* Buku tersebut tidak menargetkan ke para pembaca yang mengharapkan untuk mahir di bahasa assembly yang spesifik.
* Edisi MIPS dan ARM mencakup topik-topik yang sama tapi membedah arsitektur yang berbeda.
* Kedua edisi tersebut mengandung contoh-contoh di dunia x86.
### <a name="C-language"></a>Bahasa C
Tidak ada jalan pintas. Baca saja seluruh isi buku dan selesaikan semua latihan.
* [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504)
* [The C Programming Language 2nd Edition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* Modern C: Jens Gustedt. Modern C. Manning, 2019, 9781617295812. ffhal-02383654f
* Untuk standar C yang baru
* [Is Parallel Programming Hard, And, If So, What Can You Do About It?](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html)
* implementasi mentah sinkronisasi dengan C
* Sangat diperlukan untuk pemrograman C skala besar (terutama untuk pemrograman kernel)
* [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/)
* Jika anda selesai membaca satu atau dua buku pemrograman C, kamu HARUS membuat sesuatu.
* Pilih yang manapun yang anda sukai.
* Pertama, buatlah kode anda sendiri lalu bandingkan dengan kode orang lain. Itu sangan penting untuk membandingkan sumber anda dengan yang lain. Anda bisa bisa meningkatkan skill hanya ketika anda membaca sumber lain dan belajar metode-metode yang lebih baik. Books are dead and source is live.
* [C and other languages based projects](https://github.com/danistefanovic/build-your-own-x)
* temukan proyek-proyek menarik lainnya
* [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/)
* Referensi optimisasi menggunakan C dan sedikit x86 assembly
* Mulai dari 8088 hingga saat ini
* Berfokus khusus pada optimisasi grafik tingkat rendah
* [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming)
* Cara mengembangkan framework dan plugin di C pada perangkat lunak skala besar
* Tips-tips pemrograman yang sangat mendasar untuk membaca sumber kernel Linux
Jika anda ingin menjadi ahli pemrograman C, kunjungi https://leetcode.com/. Semoga beruntung!
### <a name="Rust-language"></a>Bahasa Rust
Saya meyakini bahwa bahasa pemrograman selanjutnya untuk pemrograman sistem adalah Rust.
Saya akan membuat daftar apa yang saya lakukan untuk belajar Rust.
[Linus Torvalds mengatakan Kecuali terjadi sesuatu yang aneh, [Rust] akan membuatnya menjadi 6.1."](https://www.zdnet.com/article/linus-torvalds-rust-will-go-into-linux-6-1/)
* [The Rust Programming Language](https://doc.rust-lang.org/book/)
* Pengenalan yang bagus, namun kurang akan contoh dan latihan-latihan.
* [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
* Ketika membaca "The Rust Programming Language", anda bisa menemukan contoh dan latihan-latihan di sini.
* Namun tidak banyak latihan yang bisa Anda lakukan sendiri. Hanya beberapa contoh termasuk latihan "lakukan ini" dan latihan tersebut sangat mudah.
* [Programming Rust, 2nd](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/)
* Pengenalan yang lebih dalam, namun masih kurang akan contoh dan latihan-latihan.
* [Exercism](https://exercism.org/tracks/rust)
* Latihan-latihan yang bagus untuk melatih fitur individu dari RUST.
* Saya tidak yakin para mentor bekerja secara aktif namun itu seharusnya cukup untuk membandingkan solusi anda dengan solusi lain.
* Setelah mengirimkan solusi anda, anda bisa melihat solusi orang lain dengan tab "Community solutions" (sejak Exercism V3).
* Banyak latihan-latihan dengan level mudah adalah untuk fitur fungsional seperti map/filter/any dan lain-lain.
* [Easy rust](https://dhghomon.github.io/easy_rust/)
* Sebuah buku yang ditulis dengan bahasa inggris yang mudah.
* Bahan ajar youtubed yang tersedia: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk
* [Let's get rusty](https://www.youtube.com/c/LetsGetRusty)
* Banyak Youtuber mengunggah kursus Rust namun saya paling menikmati kursus ini.
* Dia telah mengunggah berita terbaru untuk Rust. Layak untuk disubscribe.
* [Rust for Linux](https://github.com/Rust-for-Linux)
* Lihat sumber-sumber contoh dan cek bagaimana Rust akan masuk ke kernel Linux
## <a name="Applications"></a>Pengaplikasian
### <a name="Hardware-Firmware"></a>Hardware && Firmware
Jika anda ingin menjadi embedded system engineer, akan lebih baik untuk mulai dari sebuah hardware kit yang sederhana, daripada memulai dengan chipset ARM terbaru.
* [Arduino Start Kit](https://www.arduino.cc/)
* Ada banyak seri dari Arduino namun "Arduino Start Kit" yang punya prosesor(Atmega328P) dan buku panduan yang paling sederhana.
* Atmega328P memiliki 8-bit inti yang mana membuatnya jadi permulaan yang bagus untuk perancangan sirkuit digital dan pengembangan firmware.
* Anda tidak perlu tahu cara menggambar skema dan tata letak serta merakit chip.
* Namun anda perlu tahu cara membaca skema dan memahami bagaimana chip saling terhubung.
* Pengembang firmware seharusnya tahu cara membaca skema dan mencari tahu cara mengirim data ke perangkat target.
* Ikuti buku panduan!
* [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf)
* Jika anda pemula pada arsitektur x86, 8086 juga panduan yang sangat bagus untuk arsitektur prosesor dan assembly 80x86
* [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf)
* Panduan terbaik untuk mode terproteksi dan mekanisme paging prosesor 80x86
* Versi web: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm
Pada titik ini, anda sebaiknya mulai dengan prosesor ARM dan x86 terbaru.
* https://www.raspberrypi.org/
* https://beagleboard.org/
* https://www.arduino.cc/en/ArduinoCertified/IntelEdison
Sebagai contoh, board Raspberry Pi memiliki prosesor Cortex-A53 yang mendukung set instruksi 64-bit.
Ini mengizinkan anda untuk merasakan arsitektur prosesor modern dengan rPi.
Ya, anda bisa membelinya... namun... apa yang akan anda lakukan dengan itu?
Jika anda tidak punya target proyek, anda kemungkinan besar akan membuang boardnya ke dalam laci dan melupakannya seperti gadget lain yang mungkin pernah anda beli sebelumnya.
Jadi, saya merekomendasikan satu proyek untuk anda.
* [Making your own kernel](http://wiki.osdev.org/Getting_Started)
* Referensi bagus: https://www.reddit.com/r/osdev/
* [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* (deskripsi dari proyek) Repositori ini mengandung panduan langkah demi langkah yang mengajari cara membuat sebuah kernel sistem operasi (OS) sederhana dari awal...(skip)...Setiap pelajaran dirancang sedemikian rupa sehingga pertama-tama menjelaskan bagaimana beberapa fitur kernel diimplementasikan di OS RPi, dan kemudian mencoba mendemonstrasikan cara kerja fungsi yang sama di kernel Linux.
Saya telah membuat [kernel mainan](https://github.com/gurugio/caos) yang mendukung 64-bit long mode, paging dan context switching yang sangat sederhana. Membuat kernel mainan adalah cara yang bagus untuk memahami arsitektur komputer dan kontrol perangkat keras.
Faktanya, Anda sudah memiliki prosesor terbaru dan perangkat keras terbaru.
Laptop anda! Desktop anda! Anda telah memiliki semua yang anda perlukan untuk memulai!
Anda tidak perlu membeli apapun.
Emulator qemu dapat mengemulasi prosesor ARM dan prosesor Intel terbaru.
Jadi segala yang anda perlukan sudah ada di tangan.
Ada banyak kernel mainan dan dokumen yang dapat anda jadikan rujukan.
Install saja emulator qemu dan buatlah sebuah kernel kecil yang hanya booting, mengaktifkan paging, dan print beberapa pesan.
Kernel mainan lainnya:
* https://littleosbook.github.io/
* https://tuhdo.github.io/os01/
### <a name="Linux-kernel-and-device-driver"></a>Kernel Linux dan driver perangkat
Anda tidak perlu untuk membuat sebuah sistem operasi yang lengkap.
Bergabung ke komunitas Linux dan berpartisipasi di dalam pengembangan.
Beberapa sumber untuk pengembangan kernel Linux dan driver perangkat dari tingkat pemula ke tingkat lanjut.
* Buku-buku: Bacalah dalam urutan berikut
* [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997)
* Konsep-konsep dasar dari Unix yang diaplikasikan ke dalam semua sistem operasi.
* Buku ini adalah tempat yang sangat bagus untuk belajar konsep-konsep ini dari sistem operasi.
* [Linux Device Drivers](https://www.amazon.com/Linux-Device-Drivers-Jonathan-Corbet/dp/0596005903/ref=sr_1_4?ie=UTF8&qid=1483650712&sr=8-4&keywords=understanding+linux+kernel)
* Kerjakan semua contoh-contoh untuk diri anda sendiri
* [Linux Kernel Development](https://www.amazon.com/Linux-Kernel-Development-Robert-Love/dp/0672329468/ref=sr_1_2?ie=UTF8&qid=1483650712&sr=8-2&keywords=understanding+linux+kernel)
* Pahami perancangan kernel Linux
* [Understanding the Linux Kernel](https://www.amazon.com/Understanding-Linux-Kernel-Third-Daniel/dp/0596005652/ref=sr_1_1?ie=UTF8&qid=1483650712&sr=8-1&keywords=understanding+linux+kernel)
* Baca buku ini dan sumber kernel v2.6 sekaligus
* Jangan pernah memulai dengan versi terbaru, v2.6 sudah cukup!
* Gunakan qemu dan gdb untuk menjalankan sumber kernel baris demi baris
* http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu
* https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md
* Gunakan busybox untuk membuat filesystem paling sederhana yang hanya butuh satu detik untuk booting
* https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md
* Sumber-sumber lain: Sumber gratis yang saya rekomendasikan
* [Linux device driver labs](https://linux-kernel-labs.github.io/)
* Panduan praktis dan latihan luar biasa membuat driver perangkat Linux dengan API kernel penting
* Menurut saya dokumen ini memperkenalkan hampir semua API kernel esensial.
* [The Eudyptula Challenge](http://eudyptula-challenge.org/)
* _Sayangnya, challenge ini tidak menerima peserta challange baru karena tidak ada challange lagi._ Pengelola mengatakan dia sedang merencanakan format baru. Saya harap ini kembali secepatnya.
* Namun anda bisa mencari pertanyaan-pertanyaan challange dengan Google. Beberapa orang telah mengunggah apa yang mereka telah lakukan. Cari pertanyaan-pertanyaan dan cobalah untuk menyelesaikannya sendiri, dan bandingkan solusi anda dengan orang lain.
* Ini seperti guru privat luar biasa yang memandu Anda tentang apa yang harus dilakukan.
* Jika Anda tidak tahu harus berbuat apa, mulailah saja.
* [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os)
* Proyek ini masih belum selesai.
* Saya selalu berpikir membuat sebuah kernel yang mirip dengan kernel Linux adalah cara terbaik untuk memahami kernel Linux.
* [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv)
* mulai dari contoh driver perangkat blok sederhana (Ramdisk) dengan mode multi-queue
* maju ke lapisan blok
* Saya menyelesaikan penerjemahan ke bahasa inggris. Silakan kirimkan tanggapan Anda kepada saya.
* [md driver of Linux kernel(Korean)](https://github.com/gurugio/book_linuxkernel_md)
* bagaimana tool mdadm bekerja dan cara dia memanggil driver md
* bagaimana driver md bekerja
* [A Heavily Commemted Linux Kernel Source Code](http://www.oldlinux.org/)
* Komentar berat untuk Linux kuno v0.12.
* Sebaiknya memulai dengan OS yang lama dan sederhana.
* versi Unix: [Lions' Commentary on UNIX 6th Edition, with Source Code](https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code)
#### <a name="References"></a>Referensi
Periksa ketika anda memerlukan sesuatu
* [Free-electrons homepage](http://free-electrons.com/docs/)
* banyak file slide yang memperkenalkan topik-topik bagus, khususnya ARM-linux
* [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/)
* panduan untuk memulai pemrograman kernel
### <a name="Other-applications"></a>Penerapan lain
Ya, anda mungkin tidak tertarik pada Linux atau firmware. Jika begitu, anda bisa menemukan penerapan lain:
* Pemrograman sistem Windows & driver-driver perangkat
* Security
* Reverse engineering
Saya tidak memiliki pengetahuan apapun tentang penerapan-penerapan tersebut. Silahkan kirimkan saya informasi apapun untuk pemula.
**Kernel dan driver tidak semuanya merupakan pemrograman tingkat rendah.** Satu lagi aplikasi penting dari pemrograman tingkat rendah adalah software-defined storage atau filesystem terdistribusi. Deskripsi detailnya diluar cakupan dari dokumen ini namun ada course bagus dimana anda bisa mencoba sebuah filesystem terdistribusi sederhana.
* Course: https://pdos.csail.mit.edu/archive/6.824-2012/
* sumber referensi: https://github.com/srned/yfs
## <a name="Future-of-low-level-programming"></a>Masa depan pemrograman tingkat rendah
Saya tidak tahu masa depan, namun saya terus memperhatikans Rust.
* https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/
Jika saya bisa punya satu minggu bebas dan sendiri, saya akan belajar Rust.
Itu dikarenakan Rust ada adalah bahasa terbaru yang dapat saya gunakan untuk mengembangkan driver perangkat Linux.
* https://github.com/tsgates/rust.ko
IoT adalah tren baru, jadi ada baikny cek OS apa untuk IoT.
ARM, Samsung dan beberapa perusahaan memiliki realtime OS mereka masing-masing namun sayangnya banyak dari mereka adalah closed source.
Tetapu Linux Foundation juga memiliki sebuah solusi: Zephyr
* https://www.zephyrproject.org/
Server cloud pada mumnya memiliki banyak lapisan-lapisan; contohnya, OS host, driver kvm, proses qemu, OS guest dan service application. Sebuah container telah dikembangkan untuk menyediakan virtualisasi ringan. Dalam waktu dekat, konsep OS baru, yang disebut OS library atau Unikernel, akan menggantikan tumpukan SW untuk virtualisasi.
* http://unikernel.org/
Big data dan komputasi cloud membutuhkan penyimpanan yang semakin besar. Beberapa disk secara langsung ditanamkan di mesin server tidak memenuhi kebutuhan kapasitas, stabilitas dan performa. Oleh karena itu telah dilakukan penelitian untuk membuat sistem penyimpanan berukuran besar dengan banyak mesin penyimpanan yang dihubungkan oleh jaringan berkecepatan tinggi. Dulunya difokuskan untuk membuat satu volume penyimpanan yang besar. Namun saat ini mereka menyediakan banyak volume yang didedikasikan untuk banyak mesin virtual.
* https://en.wikipedia.org/wiki/Software-defined_storage
* https://en.wikipedia.org/wiki/Clustered_file_system
* https://en.wikipedia.org/wiki/Ceph_(software)
## <a name="How-to-start"></a>Bagaimana cara untuk memulai?
Saya menerima sebuah email yang menanyakan cara untuk memulai. Ada banyak informasi tentang buku, course dan proyek di halama ini. Itu adalah kesalahan saya yang lupa untuk menulis bagaimana untuk memulai. Sayangnya, there is no King's Road to [King's Landing](https://gameofthrones.fandom.com/wiki/King%27s_Landing). Saya hanya akan menulis apa yang saya lakukan secara berurutan. Jika anda telah melakukan sesuatu, silahkan lewati saja. LAGI, ini hanya sebuah contoh yang anda bisa lakukan secara berurutan, untuk berjaga-jaga jika Anda tidak tahu bagaimana memulainya atau apa yang harus dilakukan.
* Membaca buku-buku teori OS: setidaknya "The Design of the UNIX Operating System by Maurice J. Bach"
* Belajar assembly dan C
* [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086)
* Itu cukup jika anda mengerti konsep dari pemrograman assembly. Anda tidak perlu untuk melakukan sesuatu yang praktikal.
* [The C Programming Language 2nd Edition](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN)
* LAKUKAN YANG TERBAIK untuk menyelesaikan semua latihan!
* [C Programming: A Modern Approach
gitextract_n7o3aeqj/ ├── LICENSE ├── README.md ├── README_cn.md ├── README_cz.md ├── README_es.md ├── README_fa.md ├── README_fr.md ├── README_id.md ├── README_it.md ├── README_pt.md ├── README_ru.md ├── README_tr.md ├── README_tw.md └── _config.yml
Condensed preview — 14 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (328K chars).
[
{
"path": "LICENSE",
"chars": 35141,
"preview": " GNU GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free "
},
{
"path": "README.md",
"chars": 27821,
"preview": "**I'm getting so much spam that I've changed this repo to read-only for a while.**\n\n\nNOTICE1: Please do not copy the con"
},
{
"path": "README_cn.md",
"chars": 7581,
"preview": "* [Low-Level Programming University](#Low-Level-Programming-University)\n * [这是?](#What-is-it)\n * [什么是底层](#What-Is-the-"
},
{
"path": "README_cz.md",
"chars": 18609,
"preview": "# PROSBA O POMOC!\nProsím informujte mě (ticketem nebo pomocí pull) jestli víte o nějakých dobrých odkazech na :\n* **Prog"
},
{
"path": "README_es.md",
"chars": 29467,
"preview": "NOTA1: Por favor, no copies el contenido de esta página a tu blog. Puedes compartir esta página, pero, por favor, compár"
},
{
"path": "README_fa.md",
"chars": 23096,
"preview": "<div dir=\"auto\">\n\nتوجه: لطفا توجه داشته باشید که برنامه نویسی سطح پایین در حال حاضر متقاضیان زیادی نداشته و کمپانی های ز"
},
{
"path": "README_fr.md",
"chars": 31924,
"preview": "AVIS1: Veuillez ne pas copier le contenu de cette page sur votre blog. Vous pouvez partager cette page mais veuillez par"
},
{
"path": "README_id.md",
"chars": 30755,
"preview": "CATATAN1: Mohon untuk tidak menyalin konten pada halaman ini untuk blog anda. Anda bisa membagikan halaman ini tapi moho"
},
{
"path": "README_it.md",
"chars": 15172,
"preview": "* [Università della programmazione a basso livello](#Low-Level-Programming-University)\n * [Che cos'è](#Wh"
},
{
"path": "README_pt.md",
"chars": 31146,
"preview": "# Universidade de Programação em Baixo Nível\n\nNota 1: Por favor, não copie o conteúdo desta página para o seu blog. Você"
},
{
"path": "README_ru.md",
"chars": 26333,
"preview": "* [Университет Низкоуровневого Программирования](#Low-Level-Programming-University)\n * [Что это такое?](#What-is-it)\n "
},
{
"path": "README_tr.md",
"chars": 29581,
"preview": "UYARI1: Lütfen bu sayfanın içeriğini blogunuza kopyalamayın. Bu sayfayı paylaşabilirsiniz ama lütfen orijinal link ile "
},
{
"path": "README_tw.md",
"chars": 15161,
"preview": "RNOTICE: \nPlease notice that low-level programming is out of trend and currently \nthere are not many companies hiring "
},
{
"path": "_config.yml",
"chars": 26,
"preview": "theme: jekyll-theme-hacker"
}
]
About this extraction
This page contains the full source code of the gurugio/lowlevelprogramming-university GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 14 files (314.3 KB), approximately 88.9k tokens. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.