├── 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 /README.md: -------------------------------------------------------------------------------- 1 | **I'm getting so much spam that I've changed this repo to read-only for a while.** 2 | 3 | 4 | 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. 5 | 6 | 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. 7 | If you haven't started a professional career yet, I would like to recommend you consider other fields either carefully. 8 | 9 | NOTICE3: If you want a quick start, go to "How to start?". 10 | 11 | * [Low-Level Programming University](#low-level-programming-university) 12 | * [What is it?](#what-is-it) 13 | * [What is the Low Level](#what-is-the-low-level) 14 | * [Theory](#theory) 15 | * [Languages](#languages) 16 | * [Assembly](#assembly) 17 | * [C language](#c-language) 18 | * [Rust language](#rust-language) 19 | * [Applications](#applications) 20 | * [Hardware and Firmware](#hardware-and-firmware) 21 | * [Linux kernel and device driver](#linux-kernel-and-device-driver) 22 | * [References](#references) 23 | * [Other applications](#other-applications) 24 | * [Future of low-level programming](#future-of-low-level-programming) 25 | * [How to start?](#how-to-start) 26 | * [Translations](#translations) 27 | * [Who am I?](#who-am-i) 28 | 29 | # Low-Level Programming University 30 | 31 | ## What is it? 32 | 33 | 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. 34 | 35 | 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. 36 | 37 | Low-level programming is a part of computer science. 38 | Absolutely it would be much better to get education in computer science first. 39 | * [Path to a free self-taught education in Computer Science!](https://github.com/ossu/computer-science) 40 | 41 | 42 | ## What is the Low-Level? 43 | 44 | 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). 45 | * [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language) 46 | 47 | 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. 48 | * [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming) 49 | 50 | 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. 51 | 52 | ## Theory 53 | 54 | There are two background theories to low-level programming: 55 | * Computer Architecture 56 | * Operating Systems 57 | 58 | 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. 59 | Theory is theory. I don't think you need to get an A+ in the class, just understand the big picture. 60 | You'll get better and better with experience. 61 | 62 | 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. 63 | * Computer Architecture 64 | * Computer Architecture, Fifth Edition: A Quantitative Approach 65 | * Computer Systems: A Programmer's Perspective 66 | * Computer Organization and Design, Fourth Edition: The Hardware/Software Interface 67 | * Operating Systems 68 | * The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design 69 | * The Design of the UNIX Operating System 70 | * Operating Systems: Internals and Design Principles by William Stallings 71 | * Recommended Courses 72 | * [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94) 73 | * General Programming Skill 74 | * [Structure and Interpretation of Computer Programs](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs) 75 | * 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. 76 | * If you learn Lisp/Scheme, you should be able to learn any other language quickly. 77 | * [I've solved about 80% exercises. It should be worth to try every single exercise.](https://github.com/gurugio/sicp_exercise) 78 | * Hardware Design 79 | * Build Your Own 8086 Microprocessor Kit 80 | * If you don't build your HW board, you don't understand what physical memory mapped device is. 81 | * Modern APs includes so many IPs. So you don't have a chance to understand how CPU core and peripheral devices are connected. 82 | * 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. 83 | * 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. 84 | * Google "8086 kit". You would be able to find some web-sites you can buy a HW scheme, parts and manuals. 85 | 86 | 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.** 87 | 88 | ## Languages 89 | 90 | ### Assembly 91 | 92 | 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. 93 | 94 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 95 | * basic concepts of CPU and computer architecture 96 | * basic concepts of C programming language 97 | * [64bit assembly programming (translation in progress)](https://github.com/gurugio/book_assembly_64bit) 98 | * basic concepts of modern CPU and computer architecture 99 | * basic concepts of disassembling and debugging of C code 100 | * _need help for translation_ 101 | * [Learning assembly for linux-x64](https://github.com/0xAX/asm) 102 | * pure 64-bit assembly programming with NASM and inline assembly with GCC 103 | * [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 104 | * Complete reference on ARM programming 105 | * Computer Organization and Design 106 | * [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 107 | * [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 108 | * [RISC-V Edition](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 109 | * Academic books that explain how every component of a computer work from the ground up. 110 | * Explains in detail the different concepts that make up computer architecture. 111 | * They are not targeted at readers who wish to become proficient in a specific assembly language. 112 | * The MIPS and ARM edition cover the same topics but by dissecting a different architecture. 113 | * Both editions contain examples in the x86 world 114 | 115 | ### C language 116 | 117 | There is no shortcut. Just read the entire book and solve all the exercises. 118 | 119 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 120 | * [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) 121 | * Modern C: Jens Gustedt. Modern C. Manning, 2019, 9781617295812. ffhal-02383654f 122 | * For new standard of C 123 | * [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) 124 | * raw implementation of synchronization with C 125 | * Essential for large scale C programming (especially for kernel programming) 126 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 127 | * If you finish reading one or two C programming books, then you MUST make something. 128 | * Choose whatever you like. 129 | * 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. 130 | * [C and other languages based projects](https://github.com/danistefanovic/build-your-own-x) 131 | * find more interesting projects 132 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 133 | * Reference on optimization using C and a bit of x86 assembly 134 | * Starts from the 8088 up to today 135 | * Special focus on low-level graphics optimization 136 | * [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming) 137 | * How to develop framework and plugin in C for large scale software 138 | * Very basic programming tips for Linux kernel source reading 139 | 140 | If you want to be expert of C programming, visit https://leetcode.com/. Good luck! 141 | 142 | ### Rust language 143 | 144 | I am sure that the next language for the systems programming would be Rust. 145 | I will make a list what I did to learn Rust. 146 | 147 | [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/) 148 | 149 | * [The Rust Programming Language](https://doc.rust-lang.org/book/) 150 | * Great introduction, but lack of examples and exercises. 151 | * [Rust by Example](https://doc.rust-lang.org/rust-by-example/) 152 | * While reading "The Rust Programming Language", you can find examples and exercises here. 153 | * But there are not many exercises you can do something for yourself. Only some examples includes "do-this" exercises and they are very simple. 154 | * [Programming Rust, 2nd](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/) 155 | * Deeper introduction, but still lack of examples and exercises. 156 | * [Exercism](https://exercism.org/tracks/rust) 157 | * Good exercises to practice indivisual features of RUST. 158 | * I am not sure Mentors are working actively but it would be enough to compare your solution with others. 159 | * After submitting your solution, you can see other's solutions with "Community solutions" tab (since Exercism V3). 160 | * Many easy level exercises are for functional feature such as map/filter/any and etc. 161 | * [Easy rust](https://dhghomon.github.io/easy_rust/) 162 | * A book written in easy English. 163 | * Youtube materials provided: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk 164 | * [Let's get rusty](https://www.youtube.com/c/LetsGetRusty) 165 | * There are many Youtubers uploading Rust course but I enjoyed this course most. 166 | * He has been uploading the latest news for Rust. It's worth subscribing. 167 | * [Rust for Linux](https://github.com/Rust-for-Linux) 168 | * See the example sources and check how Rust got into the Linux kernel 169 | * [(Work In Progress) Linux Device Drivers in Rust](https://github.com/gurugio/rust-for-linux) 170 | * Writing examples in the book "Linux device drivers" with the Rust language. 171 | 172 | ## Applications 173 | 174 | ### Hardware and Firmware 175 | 176 | 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. 177 | 178 | * [Arduino Start Kit](https://www.arduino.cc/) 179 | * There are many series of Arduinos but "Arduino Start Kit" has the most simple processor(ATmega328P) and guide book 180 | * ATmega328P has an 8-bit core which is a good place to start digital circuit design and firmware development. 181 | * You don't need to know how to draw schematics and layouts and assemble the chips. 182 | * But you do need to know how to read schematics and understand how the chips are connected. 183 | * Firmware developers should be able to read the schematics and figure out how to send data to the target device. 184 | * Follow the guide book! 185 | * [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 186 | * If you're a beginner to x86 architecture, 8086 is also very good guide for processor architecture and x86 assembly 187 | * [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 188 | * Best guide for protected mode and paging mechanism of 80x86 processor 189 | * Web version: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 190 | 191 | At this point, you should be good to start the latest ARM or x86 processor. 192 | * https://www.raspberrypi.org/ 193 | * https://beagleboard.org/ 194 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 195 | 196 | For example, the Raspberry Pi board has a Cortex-A53 Processor that supports a 64-bit instruction set. 197 | This allows you to experience a modern processor architecture with rPi. 198 | Yes, you can buy it... but... what are you going to do with it? 199 | 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. 200 | 201 | So, I recommend one project for you. 202 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 203 | * Good references: https://www.reddit.com/r/osdev/ 204 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 205 | * (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. 206 | 207 | 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. 208 | 209 | In fact, you have already the latest processor and the latest hardware devices. 210 | Your laptop! Your desktop! You already have all that you need in order to start! 211 | You don't need to buy anything. 212 | The qemu emulator can emulate the latest ARM processors and Intel processors. 213 | So everything you need is already on hand. 214 | There are many toy kernels and documents you can refer to. 215 | Just install qemu emulator and make a tiny kernel that just boots, turns on paging, and prints some messages. 216 | 217 | Other toy kernels: 218 | * https://littleosbook.github.io/ 219 | * https://tuhdo.github.io/os01/ 220 | 221 | ### Linux kernel and device driver 222 | 223 | You don't need to make a complete operating system. 224 | Join the Linux community and participate in development. 225 | 226 | Some resources for Linux kernel and device driver development from beginner to advanced. 227 | * Books: Read the following in order 228 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 229 | * The basic concepts of Unix are applied into all operating systems. 230 | * This book is a very good place to learn the core concepts of operating systems. 231 | * [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) 232 | * Make all examples for yourself 233 | * [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) 234 | * Understand the design of the Linux Kernel 235 | * [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) 236 | * Read this book and the kernel source v2.6 at the same time 237 | * Never start with the latest version, v2.6 is enough! 238 | * Use qemu and gdb to run the kernel source line by line 239 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu 240 | * https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md 241 | * Use busybox to make the simplest filesystem that takes only one second to boot 242 | * https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md 243 | * Other resources: Free resources I recommend 244 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 245 | * Practical guide and excellent exercises making Linux device drivers with essential kernel APIs 246 | * I think this document introduces almost all essential kernel APIs. 247 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 248 | * _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. 249 | * 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. 250 | * This is like an awesome private teacher who guides you on what to do. 251 | * If you don't know what to do, just start this. 252 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 253 | * This project is not completed yet. 254 | * I always think making a kernel similar to the Linux kernel is the best way to understand the Linux kernel. 255 | * [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv) 256 | * start from a simple block device driver example (Ramdisk) with multi-queue mode 257 | * go forward to block layer 258 | * I completed translation into English. Please send me your feedback. 259 | * [md driver of Linux kernel(Korean)](https://github.com/gurugio/book_linuxkernel_md) 260 | * how mdadm tool works and how it calls md driver 261 | * how md driver works 262 | * [Lions' Commentary on UNIX 6th Edition, with Source Code](https://en.wikipedia.org/wiki/Lions%27_Commentary_on_UNIX_6th_Edition,_with_Source_Code) 263 | 264 | #### References 265 | 266 | Check when you need something 267 | 268 | * [Free-electrons homepage](http://free-electrons.com/docs/) 269 | * many slide files introducing good topics, specially ARM-linux 270 | * [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 271 | * guide to start kernel programming 272 | 273 | ### Other applications 274 | 275 | Yes, you might not be interested in Linux or firmware. If so, you can find other applications: 276 | * Windows systems programming & device drivers 277 | * Security 278 | * Reverse engineering 279 | 280 | I don't have any knowledge about those applications. Please send me any information for beginners. 281 | 282 | **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. 283 | * Course: https://pdos.csail.mit.edu/archive/6.824-2012/ 284 | * reference Source: https://github.com/srned/yfs 285 | 286 | ## Future of low-level programming 287 | 288 | I do not know the future, but I keep my eye on Rust. 289 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 290 | 291 | If I could have one week free and alone, I would learn Rust. 292 | That is because Rust is the latest language with which I can develop Linux device drivers. 293 | * https://github.com/tsgates/rust.ko 294 | 295 | IoT is new trend, so it's worth to check what OSs are for IoT. 296 | ARM, Samsung and some companies has their own realtime OS but sadly many of them are closed source. 297 | But Linux Foundation also has a solution: Zephyr 298 | * https://www.zephyrproject.org/ 299 | 300 | 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. 301 | * http://unikernel.org/ 302 | 303 | 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. 304 | * https://en.wikipedia.org/wiki/Software-defined_storage 305 | * https://en.wikipedia.org/wiki/Clustered_file_system 306 | * https://en.wikipedia.org/wiki/Ceph_(software) 307 | 308 | ## How to start? 309 | 310 | 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. 311 | 312 | * Reading OS theory books: at least "The Design of the UNIX Operating System by Maurice J. Bach" 313 | * Learn assembly and C 314 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 315 | * It is enough if you understand the concept of assembly programming. You do not need to do something practical. 316 | * [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) 317 | * DO YOUR BEST TO solve every single exercise! 318 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 319 | * Do something practical with C 320 | * [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. 321 | * [leetcode.com](https://leetcode.com/): If you cannot find an interesting project, it would be also good to focus on data structure and algorithm. 322 | * Do a hardware project 323 | * Raspberrypi or Arduino does not matter. You need experience to control a hardware directly with only C. ONLY C! 324 | * 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. 325 | * DO NOT use any library. You should make everything on your own, except program downloader. 326 | * Basic of the Linux kernel 327 | * Low-level programming is very close to the operating system. You should know inside of the OS. 328 | * Start with drivers 329 | * 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) 330 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 331 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 332 | * 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. 333 | * Go to the professional field 334 | * If you want to be a professional Linux Kernel Developer 335 | * 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) 336 | * Then try to make a toy kernel 337 | * [Learn operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 338 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 339 | * Write the github link to your kernel on your resume (Don't forget to write the detailed description in commit message) 340 | * Check the latest issues at https://lwn.net/ and join it. 341 | * Check "Recent kernel patches" at "https://lwn.net/Kernel/" or direct link https://lwn.net/Kernel/Patches 342 | * 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. 343 | * 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). 344 | * Report any problem if you find any: compile warnings/errors, performance drop, kernel panic/oops or any problem 345 | * If it works well, report that with the spec of your system. The patch owner would write a "Reviewed-by" tag with your name. 346 | * Find your name in kernel git log 347 | * Or find other topics 348 | * There are many fields where the low-level engineer can work: security, Compiler, Firmware, robot/car and so on 349 | 350 | # Translations 351 | 352 | Please send me the pull request if you'd like to translate this page. I'll list it here. 353 | 354 | * [Chinese (Traditional)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tw.md) 355 | * [Chinese (Simplified)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md) 356 | * [Portuguese (Brazilian)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md) 357 | * [Italian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md) 358 | * [Czech](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md) 359 | * [Russian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md) 360 | * [Turkish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tr.md) 361 | * [Persian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fa.md) 362 | * [Spanish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_es.md) 363 | * [French](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fr.md) 364 | 365 | # Who am I? 366 | 367 | 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. 368 | 369 | FYI, I have over 10 years of experience as a low-level programmer: 370 | * 80x86 Assembly programming 371 | * Hardware device with ATmel chip and firmware 372 | * C language system programming for Unix 373 | * Device driver in Linux 374 | * Linux kernel: page allocation 375 | * Linux kernel: block device driver and md module 376 | 377 | -------------------------------------------------------------------------------- /README_cn.md: -------------------------------------------------------------------------------- 1 | * [Low-Level Programming University](#Low-Level-Programming-University) 2 | * [这是?](#What-is-it) 3 | * [什么是底层](#What-Is-the-Low-Level) 4 | * [理论](#Theory) 5 | * [编程语言](#Languages) 6 | * [汇编](#Assembly) 7 | * [C语言](#C-language) 8 | * [应用层](#Applications) 9 | * [硬件 && 固件](#Hardware-Firmware) 10 | * [Linux内核和设备驱动](#Linux-kernel-and-device-driver) 11 | * [仔细阅读](#Read-carefully) 12 | * [参考目录](#References) 13 | * [底层编程的未来趋势](#Future-of-low-level-programming) 14 | * [翻译](#Translation) 15 | 16 | # Low-Level Programming University 17 | 18 | ## 这是? 19 | 20 | 这篇文章是为那些准备成为一个底层程序员的人所写。 21 | 22 | 我是受到了 [google-interview-university](https://github.com/jwasham/google-interview-university) 这篇文章的启发。 作为一个底层程序员，我想分享一下我的经验和成长为一个底层程序员的路线图，因为我发现这些底层需要的技能在不断的发生变化。另外，很多学生和初学者也会经常问我，怎么才能成为一个底层程序员或者是成为一个Linux内核工程师。 23 | 24 | 本文不可能包含所有的链接/书籍/课程。例如，本文介绍了Arduino，但是没有详细介绍Arduino和嵌入式系统。读者需要自己深入学习这方面的知识。作为一个开始，你知道了关键词"Arduino"，接下来，你可以用google 搜索Arduino，购买一套开发套件，基于开发套件在上面**自己动手做一些事情**，而不是收集链接或者是免费的书籍。请记住，本文仅仅是一个路线图，是一个指导。 25 | 26 | 又及，我作为一个底层程序员，在以下方面有超过10年的经验： 27 | * 80x86 汇编编程 28 | * 使用基于Atmel芯片和固件的硬件 29 | * Unix下C语言系统编程 30 | * Linux设备驱动开发 31 | * Linux内核: 内存页分配 32 | * Linux内核: 块设备驱动程序和 md 模块 33 | 34 | ## 什么是底层? 35 | 36 | 我把底层编程归类于非常接近设备的编程，使用比较底层的编程语言，例如C或者汇编。这与上层编程相反，例如用户空间的应用程序，使用上层的编程语言（例如，Python，Java）。 37 | * [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language) 38 | 39 | 系统编程是一个非常接近底层编程的概念。本文包含了硬件设计以及固件开发，这部分内部不是系统编程的内容。 40 | * [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming) 41 | 42 | 最后，本文包含的主题从硬件到Linux内核，这跨越了很多的层次。一篇文章无法阐述所有层次的详细内容，所以本文的目的是让你知道怎么开始成为一个底层程序员。 43 | 44 | ## 理论 45 | 46 | 底层编程有两个背景理论： 47 | * 计算机体系结构 48 | * 操作系统 49 | 50 | 你可以在在线大学上找到很很好的课程，例如Coursera.org and edx.org。但理论仅是理论，你不需要在这些课程上获得A+，但是你需要了解整个课程的大概原理。随着经验的丰富，你可以做得越来越好。 51 | 52 | ## 编程语言 53 | 54 | ### 汇编 55 | 56 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 57 | * CPU和计算机体系结构的基本概念 58 | * C语言的基本概念 59 | * [64bit assembly programming(正在翻译)](https://github.com/gurugio/book_assembly_64bit) 60 | * 现代CPU和计算机体系结构的基本概念 61 | * 分解和调试C语言的基本概念 62 | * _需要帮忙翻译_ 63 | * [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 64 | * ARM编程参考手册 65 | * 计算机组成和设计 66 | * [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 67 | * [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 68 | * 学术书籍，解释了计算机的各部分是如何从0开始工作的 69 | * 详细解释了计算机体系结构中各方面概念 70 | * 他们的目的不是让你成为特定汇编语言专家 71 | * MIPS和ARM版本阐述了同样的问题，只不过他们以不同的体系结构为例 72 | * 两个版本都包含了x86结构下的例子 73 | 74 | ### C 语言 75 | 76 | 学习C语言没有捷径，你需要读完整本书，并解决书上的练习题。 77 | 78 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 79 | * [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) 80 | * [Modern C](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf) 81 | * C语言新标准 82 | * [并行编程困难吗，如果是的，你能做点什么?](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html) 83 | * 用C语言实现同步 84 | * 大型C程序设计必备 (特别是Linux内核编程) 85 | * [C语言编程的挑战?](https://github.com/gurugio/lowlevelprogramming-university/blob/master/c-language-challenge.md) 86 | * 开始为[The Eudyptula Challenge](http://eudyptula-challenge.org/) 制作计划 87 | * 当前只有一个想法 88 | * 如果你完成了本文的所有小项目，那么你已经可以开始做大的项目了 89 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 90 | * 使用C语言和x86汇编进行优化的参考书籍 91 | * 从8088系统到现在的系统 92 | * 特别注重底层的图形优化 93 | 94 | ## 应用程序 95 | 96 | ### 硬件 && 固件 97 | 98 | 如果你想做一个嵌入式系统工程师，那最好从一个简单的硬件套件开始，而不是从最新的ARM芯片开始。 99 | 100 | * [Arduino Start Kit](https://www.arduino.cc/) 101 | * Arduino有一系列的套件，但是 "Arduino Start Kit"有最简单的处理器(Atmega328P)以及参考手册。 102 | * Atmega328P有一个8位的核心，这对于“数字电路设计”和“固件开发” 是个好的开头 103 | * 你不必要了解怎么画原理图，怎么laytou，怎么组装芯片 104 | * 但是你需要知道怎么去读原理图，并理解各芯片之间是怎么连接的 105 | * 固件工程师应该具备阅读原理图并知道怎么给目标设备发送数据的能力 106 | * 跟随参考手册的指导 107 | * [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 108 | * 如果你刚开始了解x86架构，8086手册对于理解处理器架构和80x86汇编语言也是非常好的指导 109 | * [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 110 | * 对于80x86处理器的保护模式和分页机制是最好的指导 111 | * 网络版本: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 112 | 113 | 到这个点上，你可以开始了解最新的ARM和x86处理器。 114 | * https://www.raspberrypi.org/ 115 | * https://beagleboard.org/ 116 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 117 | 118 | 例如，树莓派开发板有一个支持64位指令的Cortex-A53处理器，这可以让你了解现代处理器架构。是的，你可以买一个开发板，但是，你买来做什么呢？如果你没有目标项目，你很可能将它扔到抽屉里，然后忘在脑后。 119 | 120 | 所以，我向你推荐一个项目： 121 | * [制作自己的内核](http://wiki.osdev.org/Getting_Started) 122 | * 参考资料: https://www.reddit.com/r/osdev/ 123 | 124 | 我自己制作了[a toy kernel](https://github.com/gurugio/caos)，该内核支持64位长模式，分页以及很简单的上下文切换。制作一个简单的内核对于理解现代计算机体系结构和硬件控制是一种很好途径。 125 | 126 | 事实上，你已经有了最新的处理器和最新的硬件设备。这就是你的笔记本电脑，你的台式电脑，你已经具备所有的条件了。你不需要购买任何东西。qemu仿真器可以仿真最新的ARM和Intel处理器，所以你需要的资料都已经具备了。有很多简单内核和文档供你参考。你要做的就是安装qemu仿真器，开发一个简单内核，能够启动，开启分页功能并打印一些信息。 127 | 128 | 其他的简单内核: 129 | * https://littleosbook.github.io/ 130 | * https://tuhdo.github.io/os01/ 131 | 132 | ### Linux内核和设备驱动 133 | 134 | 你没有必要开发一个完整的操作系统，可以加入Linux社区并参与内核开发。 135 | 136 | #### 仔细阅读 137 | 138 | * 书籍: 按照如下顺序阅读 139 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 140 | * Unix系统的基本概念适用于所有的操作系统 141 | * 这本书对于理解操作系统概念非常好 142 | * [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) 143 | * 亲自做所有的例子 144 | * [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) 145 | * 理解Linux内核设计原理 146 | * [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) 147 | * 读这本书的同时也要读v2.6的内核源码 148 | * 不要读最新的源码，2.6版本足够了! 149 | * 使用quemu和gdb来一行一行的运行内核代码 150 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu 151 | * https://gurugio.kldp.net/wiki/wiki.php/howto_debug_kernel 152 | * 使用busybox来制作最简单的文件系统，使得系统能在1秒内启动 153 | * https://gurugio.kldp.net/wiki/wiki.php/qemu_kernel 154 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 155 | * 这就像一个令人敬畏的私人老师指导你该做什么 156 | * 如果你不知道做什么，那就从这里开始 157 | * [Block layer and device driver(正在翻译)](https://github.com/gurugio/book_linuxkernel_blockdrv) 158 | * 从一个简单的具备多队列模式的块设备驱动程序（Ramdisk）开始 159 | * 深入到块设备层 160 | * _需要帮忙翻译_ 161 | * [md driver of Linux kernel(正在进行)](https://github.com/gurugio/book_linuxkernel_md) 162 | * mdadm工具工作流程以及调用md驱动程序的过程 163 | * md驱动程序是怎么工作的 164 | * _需要帮忙翻译_ 165 | 166 | #### 参考 167 | 168 | 当你需要帮助时参考下面资料 169 | 170 | * [Free-electrons homepage](http://free-electrons.com/docs/) 171 | * 很多文件介绍的内容都很好，尤其是ARM-linux方面的 172 | * [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 173 | * 指导如何开始内核编程 174 | 175 | ## 底层编程的未来趋势 176 | 177 | 我不知道未来会怎么样，但是我会关注RUST。 178 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 179 | 180 | 如果我有一周的空闲时间，我会学习RUST。这是因为RUST是可以开发Linux设备驱动程序的最新的一种语言。 181 | 182 | IoT是新的趋势，所以值得我们去研究一下IoT所使用的操作系统。ARM，Samsung以及一些公司有他们自己的实时操作系统，但是糟糕的是这些系统都是闭源的。但是Linux基金会有一个解决方案：Zephyr 183 | * https://www.zephyrproject.org/ 184 | 185 | 典型的云服务器有很多层，例如主机OS，kvm驱动，qemu进程，客机OS以及应用服务程序。因此容器被开发出来以提供轻量虚拟化。在不久的将来，一种新型的OS，被称为library OS或者是Unikernel的OS，可能会取代当前的用作虚拟化的软件栈。 186 | * http://unikernel.org/ 187 | 188 | # Translation 189 | 190 | 如果你要翻译本文，请提交一个PR，我会在这里列出来。 191 | -------------------------------------------------------------------------------- /README_cz.md: -------------------------------------------------------------------------------- 1 | # PROSBA O POMOC! 2 | Prosím informujte mě (ticketem nebo pomocí pull) jestli víte o nějakých dobrých odkazech na : 3 | * **Programování Hardwaru firmwaru** 4 | * **Qemu/KVM hypervisor** 5 | * **Síťový zásobník jádra** 6 | 7 | ---- 8 | * [Univerzita nízkoúrovňového programování](#Low-Level-Programming-University) 9 | * [Co to je?](#What-is-it) 10 | * [Co to je nízkoúrovňové](#What-Is-the-Low-Level) 11 | * [Teorie](#Theory) 12 | * [Jazyky](#Languages) 13 | * [Assembly](#Assembly) 14 | * [Jazyk C](#C-language) 15 | * [Aplikace](#Applications) 16 | * [Hardware && Firmware](#Hardware-Firmware) 17 | * [Linuxové jádro a ovladač zařízení](#Linux-kernel-and-device-driver) 18 | * [Pečlivě prostudujte](#Follow-carefully) 19 | * [Odkazy](#References) 20 | * [Jiné aplikace](#Other-applications) 21 | * [Budoucnost nízkoúrovňového programování](#Future-of-low-level-programming) 22 | * [Překlad](#Translation) 23 | * [Kdo jsem?](#who-am-i) 24 | 25 | # Univerzita nízkoúrovňového programování 26 | 27 | ## Co to je? 28 | 29 | 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. 30 | 31 | 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. 32 | 33 | ## Co to je nízkoúrovňové? 34 | 35 | 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). 36 | * [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language) 37 | 38 | 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. 39 | * [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming) 40 | 41 | 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í. 42 | 43 | ## Teorie 44 | 45 | Základní teorie pro nízkoúrovňové programování jsou dvě: 46 | * Stavba (architektura) počítače 47 | * Operační systémy 48 | 49 | 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. 50 | Teorie je teorie. Nemyslím, že musíte obdržet nejlepší známku, jde o to udělat si obrázek. 51 | Stále se budete zlepšovat zkušenostmi. 52 | 53 | 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. 54 | 55 | * Počítačová architektura 56 | * Computer Architecture, Fifth Edition: A Quantitative Approach 57 | * Computer Systems: A Programmer's Perspective 58 | * Computer Organization and Design, Fourth Edition: The Hardware/Software Interface 59 | * Operační systémy 60 | * The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design 61 | * The Design of the UNIX Operating System 62 | * Operating Systems: Internals and Design Principles by William Stallings 63 | * Doporučené kurzy 64 | * [CS401: Operating Systems from saylor.org](https://learn.saylor.org/mod/page/view.php?id=921) 65 | 66 | 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í.** 67 | 68 | ## Jazyky 69 | 70 | ### Assembly 71 | 72 | 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. 73 | 74 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 75 | * základní koncepty CPU a počítačové architektury 76 | * základní koncepty programovacího jazyka C 77 | * [64bit assembly programming(na překladu ještě pracuji)](https://github.com/gurugio/book_assembly_64bit) 78 | * základní koncepty moderní CPU a počítačové architektury 79 | * základní koncepty převodu ze strojového kódu a opravování kódu v jazyce C 80 | * _potřebuji pomoci s překladem_ 81 | * [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 82 | * Kompletní reference o ARM programování 83 | * Organizace počítače a design 84 | * [MIPS edice](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 85 | * [ARM edice](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 86 | * [RISC-V edice](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 87 | * Akademické knihy, které vysvětlují jak jednotlivé komponenty počítače pracují od základů. 88 | * Detailně vysvětlují rozdílné koncepty, které tvoří stavbu počítače. 89 | * nejsou určeny čtenářům, kteří se chtějí stát zdatnými v určitém assembly jazyku. 90 | * MIPS a ARM edice pokrývají ta samá témata, ale rozpitvávají rozdílné architektury. 91 | * Obě edice obsahují příklady ve světě x86. 92 | 93 | ### Jazyk C 94 | 95 | Tady neexistuje zkratka. Jen přečtěte jednu celou knihu a vyřešte všechny příklady. 96 | 97 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 98 | * [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) 99 | * [Modern C](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf) 100 | * Pro nový standard C 101 | * [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) 102 | * hrubá implementace a synchronizace s C 103 | * Základy pro rozsáhlé C programování (zvláště pro programování jádra) 104 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 105 | * Poté, co přečtete jednu či dvě knihy o programování v C, ihned MUSÍTE něco dělat. 106 | * Vyberte si, co chcete. 107 | * 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ý. 108 | * [Projekty založené na C a dalších jazycích](https://github.com/danistefanovic/build-your-own-x) 109 | * najděte si více zajímavých projektů 110 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 111 | * Reference na optimalizaci za použití C a části x86 assembly 112 | * Začíná 8088 a pokračuje až do současnoti 113 | * Speiálně se zaměřuje na nízkoúrovňovou grafickou optimalizaci 114 | 115 | Chcete-li být expertem na programování v C, navštivte https://leetcode.com/. Hodně štěstí! 116 | 117 | ## Aplikace 118 | 119 | ### Hardware && Firmware 120 | 121 | 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. 122 | 123 | * [Arduino Start Kit](https://www.arduino.cc/) 124 | * K dispozici je mnoho sérií Arduina, ale "Arduino Start Kit" má nejjednodušší procesor(Atmega328P) a knihu návodů. 125 | * 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. 126 | * Nepotřebujete vědět jak kreslit schémata a plánky a sestavit čip. 127 | * Musíte ale vědět, jak číst schémata a porozumět zapojení čipů. 128 | * Vývojáři firmwaru by měli být schopni číst schémata a zjistit, jak poslat data do cílového zařízení. 129 | * Postupujte podle knihy návodů! 130 | * [8086 manuál](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 131 | * Pokud jste nováčkem co se týká x86 architektury, 8086 je také velmi dobrý návod co do stavby procesoru a 80x86 assembly 132 | * [80386 manuál](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 133 | * Nejlepší návod pro chráněný mód a stránkovací mechanismus procesorů 80x86 134 | * Webovská verze: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 135 | 136 | V tomto bodě by jste měli být dost dobří na to začít s nejnovějšími ARM nebo x86 procesory. 137 | * https://www.raspberrypi.org/ 138 | * https://beagleboard.org/ 139 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 140 | 141 | Například Raspberry Pi deska má Cortex-A53 procesor, který podporuje 64-bitové sady instrukcí. 142 | To vám dovoluje si vyzkoušet moderní procesorovou architekturu s rPi. 143 | Ano, můžete si ti koupit... ale... co s tím budete dělat? 144 | 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. 145 | 146 | Takže vám doporučuji jeden projekt. 147 | * [Vytvoření vlastního jádra](http://wiki.osdev.org/Getting_Started) 148 | * Dobré podklady: https://www.reddit.com/r/osdev/ 149 | * [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) 150 | * (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. 151 | 152 | 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. 153 | 154 | 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! 155 | Nemusíte nic kupovat. 156 | Qemu emulátor může napodobit poslední ARM procesory a procesory Intel. 157 | Takže všechno, co potřebujete, už máte v rukou. 158 | Je mnoho jader na hraní a dokumentací z kterých můžete těžit. 159 | Stačí si nainstalovat qemu emulátor a vyrobit drobné jádro, které bootuje, začne stránkovat a tiskne zprávy. 160 | 161 | Další jádra na hraní: 162 | * https://littleosbook.github.io/ 163 | * https://tuhdo.github.io/os01/ 164 | 165 | ### Linuxové jádro a ovladač zařízení 166 | 167 | Nepotřebujete vytvořit kompletní operační systém. 168 | Připojete se ke komunitě a podílejte se na vývoji. 169 | 170 | #### Důsledně nastudujte 171 | 172 | * Knihy: Přečtěte v následujícím pořadí 173 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 174 | * Základní koncepty Unixu jsou aplikovány do všech operačních systémů. 175 | * Tato kniha je dobrým místem, kde se naučit základní postupy operačních systémů. 176 | * [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) 177 | * Sami vyřešte všechny příklady 178 | * [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) 179 | * Porozumějte designu Linuxového jádra 180 | * [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) 181 | * Přečtěte tuto knihu a zdrojový kód jádra v2.6 zároveň 182 | * Nikdy nezačínejte s nejnovější verzí, v2.6 je dostačující! 183 | * Použijte qemu a gdb ke spouštění zdrojového kódu jádra řádek po řádku 184 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu 185 | * https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md 186 | * Použijte busybox k vytvoření toho nejjednoduššího systému souborů, jehož bootování zabere pouze jednu sekundu 187 | * https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md 188 | * Jiné zdroje: Ze zdrojů, co jsou zadarmo doporučuji 189 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 190 | * Praktický průvodce a vynikající příklady vytváření Linuxových ovladačů zařízení se základními jádrovými aplikacemi 191 | * Myslím, že tento dokument představuje téměř všechny podstatné jádrové aplikace. 192 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 193 | * _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. 194 | * 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. 195 | * To je jako zatraceně dobrý soukromý učitel, který vás vede k tomu, co by se mělo dělat. 196 | * Jesliže nevíte, co dělat, prostě začněte tímto. 197 | * [Blokovací vrstva a ovladač zařízení](https://github.com/gurugio/book_linuxkernel_blockdrv) 198 | * začněte jednoduchým příkladem blokovacího ovladačem zařízení (Ramdisk) s multi-frontovým módem 199 | * jděte dál až ke blokovací vrstvě 200 | * Dokončil jsem překlad do angličtiny. Dejte mi prosím zpětnou vazbu. 201 | * [md ovladač Linuxového jádra (korejsky)](https://github.com/gurugio/book_linuxkernel_md) 202 | * jak mdadm nástroj funguje a jak volá md ovladač 203 | * jak md ovladač funguje 204 | * [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) 205 | * Tento projekt ještě není dokončen. 206 | * Vždy si myslím, že vytvoření jádra podobného tomu Linuxovému je nejlepší cestou k porozumění jádra Linuxu. 207 | 208 | #### Dokumentace 209 | 210 | Projděte, když něco potřebujete 211 | 212 | * [Domovská stránka volné elektroniky](http://free-electrons.com/docs/) 213 | * mnoho souborů s prezentacemi představujícími dobrá témata, hlavně ARM-linux 214 | * [Blogy Julie Evansové: Můžeš být jádrový hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 215 | * návod, jak začít s programováním jádra 216 | 217 | ### Jiné aplikace 218 | 219 | Ano, nemusí vás zajímat Linux nebo firmware. Pokud tomu tak je, můžete nalézt jiná uplatnění: 220 | * Programování systému Windows & ovladače zařízení 221 | * Zabezpečení 222 | * Reverzní inženýrství 223 | 224 | Nemám žádné znalosti o těchto uplatněních. Prosím pošlete mi nějaké informace pro začátečníky. 225 | 226 | **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. 227 | * Kurz: https://pdos.csail.mit.edu/archive/6.824-2012/ 228 | * zdrojový kód dokumentace: https://github.com/srned/yfs 229 | 230 | ## Budoucnost nízkoúrovňového programování 231 | 232 | Neznám budoucnost, ale sleduji RUST. 233 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 234 | 235 | Kdybych měl týden volna, učil bych se RUST. 236 | A to proto, že RUST je nejnovější jazyk se kterým mohu vyvíjet Linuxové ovladače zařízení. 237 | * https://github.com/tsgates/rust.ko 238 | 239 | 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á. 240 | 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. 241 | Ale Linux Foundation má také řešení: Zephyr 242 | * https://www.zephyrproject.org/ 243 | 244 | 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. 245 | * http://unikernel.org/ 246 | 247 | 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ů. 248 | * https://en.wikipedia.org/wiki/Software-defined_storage 249 | * https://en.wikipedia.org/wiki/Clustered_file_system 250 | * https://en.wikipedia.org/wiki/Ceph_(software) 251 | 252 | # Překlad 253 | 254 | Prosím pošlete mi pull request, pokud chcete přeložit tuto stránku. Uvedu jej zde. 255 | 256 | * [čínština](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md) 257 | * [portugalština (Brazílie)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md) 258 | * [italština](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md) 259 | 260 | # Kdo jsem? 261 | 262 | 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. 263 | 264 | Pro vaši informaci, mám přes deset let zkušeností coby nízkoúrovňový programátor: 265 | * 80x86 Assembly programování 266 | * Hardwarová zařízení s čipem Atmel a firmware 267 | * Systémové programování v jazyku C pro Unix 268 | * Ovladače zařízení v Linuxu 269 | * Linuxové jádro: stránková alokace 270 | * Linuxové jádro: blokovací ovladač zařízení a md modul 271 | -------------------------------------------------------------------------------- /README_es.md: -------------------------------------------------------------------------------- 1 | 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 2 | 3 | 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. 4 | Si no has iniciado tu carrera profesional todavía, te recomiendo que consideres otros campos cuidadosamente. 5 | 6 | NOTA3: Si quieres un inicio rápido, ve a la sección "¿Cómo empezar?" 7 | 8 | * [Universidad de programación a bajo nivel](#Universidad-de-programación-a-bajo-nivel) 9 | * [Qué es](#Qué-es) 10 | * [Qué es el bajo nivel](#Qué-es-el-bajo-nivel) 11 | * [Teoría](#Teoría) 12 | * [Lenguajes](#Lenguajes) 13 | * [Ensamblador](#Ensamblador) 14 | * [Lenguaje C](#Lenguaje-C) 15 | * [Lenguaje Rust](#Lenguaje-Rust) 16 | * [Aplicaciones](#Aplicaciones) 17 | * [Hardware y firmware](#Hardware-y-firmware) 18 | * [Núcleo Linux y controladores de dispositivos](#Núcleo-Linux-y-controladores-de-dispositivos) 19 | * [Referencias](#Referencias) 20 | * [Otras aplicaciones](#Otras-Aplicaciones) 21 | * [Futuro del bajo nivel](#Futuro-del-bajo-nivel) 22 | * [Cómo empezar](#Cómo-empezar) 23 | * [Traducción](#Traducción) 24 | * [Quién soy](#Quién-soy) 25 | 26 | 27 | # Universidad de programación a bajo nivel 28 | 29 | ## ¿Qué es? 30 | 31 | 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. 32 | 33 | 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. 34 | 35 | La programación a bajo nivel es una parte de las ciencias de la computación. 36 | Por supuesto, será mucho mejor educarse un poco sobre las ciencias de la computación primero. 37 | * [Ruta para una educación autodidacta en ciencias de la computación](https://github.com/ossu/computer-science) 38 | 39 | ## ¿Qué es el bajo nivel? 40 | 41 | 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. 42 | * [Wikipedia: Lenguaje de bajo nivel](https://es.wikipedia.org/wiki/Lenguaje_de_bajo_nivel) 43 | 44 | 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. 45 | * [Wikipedia en inglés: Systems Programming](https://en.wikipedia.org/wiki/Systems_programming) 46 | 47 | 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. 48 | 49 | ## Teoría 50 | La base teórica de la programación a bajo nivel tiene dos componentes principales: 51 | * La arquitectura de computadoras 52 | * Los sistemas operativos 53 | 54 | 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). 55 | La teoría es teoría. No creo que necesites tener un 10 en clase, sólo entiende el panorama general. 56 | La experiencia te hará cada vez mejor. 57 | 58 | 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: 59 | * Arquitectura de computadoras 60 | * Computer Architecture: A Quantitative Approach, quinta edición. 61 | * Computer Systems: A Programmer's Perspective. 62 | * Computer Organization and Design: The Hardware/Software Interface, cuarta edición. 63 | * Sistemas operativos 64 | * The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design. 65 | * The Design of the UNIX Operating System. 66 | * Operating Systems: Internals and Design Principles by William Stallings. 67 | * Cursos recomendados 68 | * [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94) 69 | * Habilidad general de programación 70 | * [Estructura e interpretación de los programas de ordenador](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs) 71 | * 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. 72 | * 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. 73 | * [He resuelto aproximadamente el 80% de los ejercicios. Valdría la pena intentarlos todos](https://github.com/gurugio/sicp_exercise) 74 | * Diseño Hardware 75 | * Kit para construir tu propio microprocesador 8086 76 | * Si no te construyes tu propia placa HW, no entenderás lo que es un dispositivo con memoria física mapeada. 77 | * 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. 78 | * 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. 79 | 80 | 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. 81 | 82 | ## Lenguajes 83 | 84 | ### Ensamblador 85 | 86 | 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. 87 | 88 | * [Programación en ensamblador de 8086 con emu8086](https://github.com/gurugio/book_assembly_8086) 89 | * Conceptos básicos de un procesador y de la arquitectura de computador. 90 | * Conceptos básicos del lenguaje C. 91 | * [Programación en ensamblador x64 (traducción en curso)](https://github.com/gurugio/book_assembly_64bit) 92 | * Conceptos básicos de arquitecturas y procesadores modernos. 93 | * Conceptos básicos de desensamblado y depurado de código C. 94 | * _se necesita ayuda con la traducción_. 95 | * [Aprendiendo ensamblador para Linux-x64](https://github.com/0xAX/asm) 96 | * Programación en puro ensamblador de 64-bits con NASM y programación de *inline assembly* con GCC. 97 | * [Manual de refernecia de la arquitectura ARM](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-97802017) 98 | * Referencia completa para la programación en ARM. 99 | * Estructura y diseño de computadoras 100 | * [Edición MIPS](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 101 | * [Edición ARM](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 102 | * [Edición RISC-V](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 103 | * Libros académicos que explican cómo funcionan los componentes de una computadora. 104 | * Explican en detalle los diferentes conceptos que forman parte de la arquitectura de la computadora. 105 | * No son para aquellos lectores que quieran profundizar en un dialecto específico de ensamblador. 106 | * Las ediciones de MIPS y ARM cubern los mismos temas pero diseccionando una arquitectura diferente. 107 | * Ambas ediciones contienen ejemplos del mundo real en x86. 108 | 109 | 110 | ### Lenguaje C 111 | * [Programación en C: Una aproximación moderna, 2ª edición](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 112 | * [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) 113 | * Modern C: Jens Gustedt. Modern C. Manning, 2019, 9781617295812. ffhal-02383654f 114 | * For new standard of C 115 | * [¿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) 116 | * Ejemplo de sincronización con C. 117 | * Esencial para programación en C a gran escala (sobretodo para programación de núcleos de sistemas operativos). 118 | * [Tutoriales de C de tipo proyecto](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 119 | * Después de terminar uno o dos libros sobre C, es importante ponerse a hacer algo con ello. 120 | * 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. 121 | * [Proyectos basados en C y otros lenguajes](https://github.com/danistefanovic/build-your-own-x) 122 | * Sirve para encontrar proyectos interesantes. 123 | * [El libro negro de la programación gráfica, por Michael Abrash. Edición especial](http://www.jagregory.com/abrash-black-book/) 124 | * Referencia acerca de la optimización en C y un poco de ensamblador de x86. 125 | * Comienza con el 8088 y progresa hasta hoy. 126 | * Énfasis en la optimización de gráficos a bajo nivel. 127 | * [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming) 128 | * Cómo desarrollar frameworks y plugins en C para software de gran escala. 129 | * Pistas básicas de programación para leer el código del núcleo Linux. 130 | 131 | Si quieres convertirte en un experto de la programación en C, visita [Leetcode](https://leetcode.com/). ¡Buena suerte! 132 | 133 | 134 | ### Lenguaje Rust 135 | 136 | Estoy convencido de que Rust será el siguiente lenguaje para la programación de sistemas. 137 | Haré una lista con lo que yo hice para aprender Rust. 138 | 139 | [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/) 140 | 141 | * [El lenguaje de programacíón Rust](https://doc.rust-lang.org/book/) 142 | * Es una buena introducción, pero le faltan ejemplos y ejercicios. 143 | * [Rust a través de ejemplos](https://doc.rust-lang.org/rust-by-example/) 144 | * Mientras lees "El lenguaje de programación Rust", puedes encontrar los ejemplos y los ejercicios en este. 145 | * 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. 146 | * [Programando Rust, 2ª](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/) 147 | * Introducción más en profundidad, pero siguen faltando ejercicios y ejemplos. 148 | * [Exercism](https://exercism.org/tracks/rust) 149 | * Buenos ejercicios para practicar características individuales de Rust. 150 | * No estoy seguro de que los Mentores estén funcionando activamente, pero sería suficiente para comparar tus soluciones con las de otros. 151 | * Después de subir tu solución puedes ver las de otros en la pestaña de "Community solutions" (Exercism V3). 152 | * Muchos ejercicios de nivel fácil son para funcionalidades de tipo map/filter/any, etc. 153 | * [Easy rust](https://dhghomon.github.io/easy_rust/) 154 | * Un libro escrito en inglés sencillo. 155 | * Trae material de Youtube: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk 156 | * [Let's get rusty](https://www.youtube.com/c/LetsGetRusty) 157 | * Hay muchos youtubers subiendo contenido de Rust, pero este lo he disfrutado especialmente. 158 | * Además ha estado subiendo las últimas noticias sobre Rust. Merece la pena suscribirse. 159 | * [Rust for Linux](https://github.com/Rust-for-Linux) 160 | * Mira el código de ejemplo y comprueba cómo Rust se introducirá en el núcleo Linux. 161 | 162 | ## Aplicaciones 163 | 164 | ### Hardware y firmware 165 | 166 | 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. 167 | 168 | * [Kit de iniciación de Arduino](https://www.arduino.cc) 169 | * Hay muchas series de Arduino, pero su kit de iniciación (Start Kit) tiene un microprocesador muy simple (Atmega328P) y un libro guía. 170 | * 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. 171 | * No necesitas saber dibujar esquemáticos ni diseños ni a soldar los chips. 172 | * Pero sí necesitas saber cómo leer los esquemáticos y entender cómo están conectados los chips. 173 | * Los desarrolladores de firmware deben ser capaces de leer los esquemáticos y averiguar cómo enviar datos al dispositivo que sea. 174 | * ¡Sigue el libro guía! 175 | * [Manual de 8086](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 176 | * Si eres un principiante con la arquitectura x86, 8086 puede servir muy bien como guía para aprender ensamblador de 80x86. 177 | * [Manual de 80386](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 178 | * La mejor guía sobre el modo protegido y el mecanismo de paginación en procesadores 80x86. 179 | * [Versión web](https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm) 180 | 181 | 182 | Llegados a este punto podrías empezar con los últimos procesadores de ARM o x86: 183 | * https://www.raspberrypi.org/ 184 | * https://beagleboard.org/ 185 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 186 | 187 | Por ejemplo, la placa Raspberry Pi tiene un Cortex-A53 y suporta un juego de instrucciones de 64 bits. 188 | Esto permite que experimentes un procesador con arquitectura más moderna. 189 | Sí, puedes comprarte una rPi, pero, ¿qué harás con ella? 190 | Si no tienes un proyecto pensado, probablemente la rPi acabará en un cajón guardada y olvidada con los otros cachivaches. 191 | 192 | Así que te recomiendo un proyecto: 193 | * [Hacer tu propio núcleo](http://wiki.osdev.org/Getting_Started) 194 | * Buenas referencias en [Reddit](https://www.reddit.com/r/osdev) 195 | * [Aprendiendo desarrollo de sistemas operativos usando el núcleo Linux y Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 196 | 197 | 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. 198 | 199 | De hecho, es probable que tengas un procesador moderno con dispositivos hardware moderno. 200 | ¡Tu portátil! ¡Tu ordenador de escritorio! Ya tienes todo lo que necesitas para empezar. 201 | No necesitas comprar nada más. 202 | El emulador QEMU puede emularte los últimos procesadores de ARM y de Intel. 203 | Así que todo lo que necesitas ya está al alcance de tu mano. 204 | Hay muchos núcleos hechos por aficionados y documentos a los que acudir. 205 | Tan solo instala QEMU y haz un núcleo pequñito que tan solo arranque, comience la paginación e imprima algunos mensajes. 206 | 207 | Otros núcleos aficionados o de juguete: 208 | * https://littleosbook.github.io/ 209 | * https://tuhdo.github.io/os01/ 210 | 211 | ### Núcleo Linux y controladores de dispositivos 212 | 213 | No necesitas hacer un sistema operativo completo. 214 | Únete a la comunidad Linux y participa en el desarrollo. 215 | 216 | Algunos recursos acerca del núcleo Linux y el desarrollo de controladores de novato a experto. 217 | * Libros: Lee los siguientes en orden 218 | * [El diseño del sistema operativo Unix](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 219 | * Los conceptos básicos de Unix se aplican en casi todos los sistemas operativos. 220 | * Este libro es un muy buen punto de partida para aprender los conceptos clave de los sistemas operativos. 221 | * [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) 222 | * Haz todos los ejemplos por ti mismo. 223 | * [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) 224 | * Entender el diseño del núcleo Linux. 225 | * [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) 226 | * Lee este libro y el código de Linux en la versión 2.6 al mismo tiempo 227 | * No empieces con la última versión, utiliza la 2.6. 228 | * Utiliza QEMU y GDB para correr el núcleo línea a línea. 229 | * [Depurar Linux con QEMU y GDB](http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu) 230 | * https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md 231 | * Utiliza busybox para hacer el sistema de ficheros más simple y que tome sólo un segundo el arrancarlo. 232 | * https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md 233 | * Otros recursos: recursos gratis que recomiendo 234 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 235 | * Guía práctica y ejercicios excelentes para hacer controladores de Linux con APIs esenciales del núcleo. 236 | * Creo que este documento introduce casi todas las APIs esenciales de Linux. 237 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 238 | * _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. 239 | * 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. 240 | * Es como un profesor privado que te va guiando. 241 | * Si no sabes bien qué hacer, este es un buen punto de partida también. 242 | * [Aprendiendo desarrollo de sistemas operativos usando el núcleo Linux y Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 243 | * Este proyecto no está terminado todavía. 244 | * Siempre pienso que hacer un núcleo similar a Linux es la mejor forma de entender Linux. 245 | * [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv) 246 | * Empieza con un ejemplo simple de controlador de dispositivo de bloques (Ramdisk) con modo multi-queue. 247 | * Avanza hasta llegar a la capa de bloques (*block layer*). 248 | * He terminado la traducción a inglés. Por favor, enviadme vuestra opinión. 249 | * [Controlador md del núcleo Linux (coreano)](https://github.com/gurugio/book_linuxkernel_md) 250 | * Cómo funciona la herramienta `mdadm` y cómo llama al controlador `md`. 251 | * Cómo funciona el controlador `md`. 252 | * [Código de Linux muy comentado](http://www.oldlinux.org/) 253 | * Versión 0.12 de Linux con un montón de comentarios útiles. 254 | * Puede ser bueno comenzar con un sistema operativo viejo y simple. 255 | * 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) 256 | 257 | 258 | ### Referencias 259 | 260 | Échales un ojo cuando necesites algo: 261 | * [Página principal de Free-electrons](http://free-electrons.com/docs/) 262 | * Muchas diapositivas/transparencias que introducen temas interesantes, especialmente ARM-Linux. 263 | * [¡Puedes ser un Kernel Hacker! Post de Julia Evans](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 264 | * Guía para empezar la programación de núcleos. 265 | 266 | 267 | ### Otras aplicaciones 268 | 269 | Puede que no estés interesado en Linux o en el firmware. De ser así, puedes encontrar otros usos: 270 | * Programación de sistemas y controladores para Windows. 271 | * Seguridad 272 | * Ingeniería inversa 273 | 274 | No sé mucho acerca de estos usos. Por favor, enviadme cualquier información que sea para principiantes. 275 | 276 | **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: 277 | * Curso: https://pdos.csail.mit.edu/archive/6.824-2012/ 278 | * Código de referencia: https://github.com/srned/yfs 279 | 280 | ## Futuro del bajo nivel 281 | 282 | No sé qué deparará el futuro, pero me mantengo atento a Rust. 283 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 284 | 285 | Si tuviese una semana libre para pasarla solo, aprendería Rust. 286 | Esto es porque es el último lenguaje en el que se pueden desarrollar controladores para Linux. 287 | * https://github.com/tsgates/rust.ko 288 | 289 | IoT es una tendencia nueva, así que merece la pena mirar qué S.O. se utiliza para IoT. 290 | 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. 291 | La Fundación Linux tiene una solución: Zephyr 292 | * [Zephyr](https://www.zephyrproject.org/) 293 | 294 | 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. 295 | * https://unikernel.org 296 | 297 | 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: 298 | * `EN` https://en.wikipedia.org/wiki/Software-defined_storage 299 | * `EN` https://en.wikipedia.org/wiki/Clustered_file_system 300 | * https://es.wikipedia.org/wiki/Ceph_File_System 301 | 302 | ## Cómo empezar 303 | 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. 304 | 305 | * Leer libros de teoría de sistemas operativos: al menos "El diseño del sistema operativo Unix" de Maurice J. Bach 306 | * Aprender ensamblador y C 307 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 308 | * Es suficiente si entiendes el concepto de programación en ensamblador. No hace falta que hagas algo práctico. 309 | * [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) 310 | * Intenta resolver todos los ejercicios por ti mismo, es importante. 311 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 312 | * Haz algo práctico con C 313 | * [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. 314 | * [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. 315 | * Haz un proyecto hardware 316 | * Raspberry Pi o Arduino, no importa. Necesitas experiencia para controlar el hardware directamente sólo con C. ¡SÓLO CON C! 317 | * 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)). 318 | * NO USES LIBRERÍAS. Deberías intentar hacerlo todo por ti mismo, 319 | * Cosas básicas del núcleo Linux 320 | * Deberías entender antes las entrañas del sistema operativo. 321 | * Comienza con controladores 322 | * 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) 323 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 324 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 325 | * 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. 326 | * Ve al sector profesional 327 | * Si quieres ser un desarrollador de Linux profesional 328 | * 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) 329 | * Intenta hacer un núcleo de juguete 330 | * [Aprende desarrollo de sistemas opeartivos con el núcleo Linux y Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 331 | * [Haz tu propio núcleo](http://wiki.osdev.org/Getting_Started) 332 | * Pon un enlace a tu Github/Gitlab en tu CV (recuerda poner mensajes de commit claros). 333 | * Mantente actualizado con lo publicado en https://lwn.net/ ¡y suscríbete! 334 | * Comprueba los "Recent Kernel Patches" en https://lwn.net/Kernel/ o https://lwn.net/Kernel/Patches. 335 | * 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. 336 | * 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. 337 | * Notifica cualquier problema que te encuentres: errores o avisos de compilación, bajadas de rendimiento, kernel panic/oops o cualquier otro problema. 338 | * 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. 339 | * ¡Encuentra tu nombre en el `git log` del núcleo! 340 | * O encuentra otros temas 341 | * 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. 342 | 343 | # Traducción 344 | 345 | Por favor, mándame el Pull Request si te gustaría traducir esta página. 346 | 347 | # Quién soy 348 | 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. 349 | 350 | Para tu información, tengo más de 10 años de experiencia como programador a bajo nivel: 351 | * Programación en ensamblador 80x86 352 | * Dispositivos hardware y firmware con chips Atmel 353 | * Programación de sistemas para Unix en C 354 | * Controladore de dispositivos en Linux 355 | * Núcleo Linux: paginación 356 | * Núcleo Linux: Módulo `md` y controladores para dispositivos de bloques. 357 | -------------------------------------------------------------------------------- /README_fa.md: -------------------------------------------------------------------------------- 1 |
2 | 3 | توجه: لطفا توجه داشته باشید که برنامه نویسی سطح پایین در حال حاضر متقاضیان زیادی نداشته و کمپانی های زیادی اقدام به استخدام برنامه نویس سطح پایین نمی کنند. برای من هم پیدا کردن شغلی در این رابطه همواره سخت تر می‌شود. به همین دلیل توصیه می‌کنم اگر هنوز فعالیت حرفه‌ای خود را شروع نکرده‌اید، سایر زمینه‌ها را نیز در نظر بگیرید. 4 | 5 | - [دانشگاه برنامه‌نویسی سطح پایین]() 6 | - [در چه مورد صحبت می‌کنیم؟]() 7 | - [سطح پایین به چه معناست؟ ]() 8 | - [تئوری]() 9 | - [زبان‌ها]() 10 | - [اسمبلی]() 11 | - [سی](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fa.md#سی) 12 | - [اپلیکیشن‌ها]() 13 | - [سخت‌افزار و ثابت‌افزار]() 14 | - [هسته و درایور لینوکس]() 15 | - [منابع]() 16 | - [سایر اپلیکیشن‌ها]() 17 | - [آینده برنامه‌نویسی سطح پایین]() 18 | - [چطور شروع کنیم؟]() 19 | - [ترجمه]() 20 | - [درباره مولف]() 21 | 22 | دانشگاه برنامه‌نویسی سطح پایین: 23 | ------------------------------------------------------- 24 | **در چه مورد صحبت می‌کنیم؟** 25 | ------------------------------------------------------- 26 | 27 | در نگارش این مقاله از [google-interview-university ](https://github.com/jwasham/coding-interview-university) الهام گرفته‌ شده است. مایل هستم تجارب خود در این زمینه را به اشتراک بگذارم و راه تبدیل شدن به یک برنامه‌نویس سطح پایین را نشان دهم، زیرا حس می‌کنم این مهارت‌ها 28 | به‌اندازه گذشته متداول نیستند. بعلاوه بسیاری از دانشجویان سوالاتی درباره اینکه چگونه برنامه‌نویس سطح پایین یا مهندس هسته لینوکس شوند می‌پرسند. 29 | 30 | این صفحه نمی‌تواند تمامی دوره‌های آموزشی، لینک‌ها و کتاب‌ها را در بر بگیرد. 31 | بعنوان مثال این صفحه آردوئینو را معرفی می‌کند ولی به بررسی جزئیات آردوئینو و سیستم‌های نهفته نمی‌پردازد و خودتان باید اطلاعات بیشتری در این مورد بدست بیاورید. برای این کار، کلیدواژه "آردوئینو" را در اختیار دارید و به‌کمک آن می‌توانید شروع کنید. بنابراین گام‌های بعدی احتمالا جستجوی واژه "آردوئینو" در گوگل، خرید یک کیت و انجام دادن کاری از سوی خودتان می‌باشند نه جمع‌آوری لینک و کتب رایگان. لطفا بخاطر داشته باشید که این صفحه تنها راهنمایی برای مبتدیان است. 32 | 33 | برنامه‌نویسی سطح پایین بخشی از علوم کامپیوتر است.مطمئنا بهتر است در ابتدا تحصیلاتی در زمینه علوم کامپیوتر انجام شود. 34 | 35 | - [مسیر تحصیل علوم کامپیوتر بصورت آزاد و خودآموز.](https://github.com/ossu/computer-science) 36 | 37 | - سطح پایین به چه معناست؟ 38 | --------------------------------------------------------- 39 | من برنامه‌نویسی سطح پایین را برنامه‌نویسی که به ماشین خیلی نزدیک است و از زبان‌های سطح پایین همچون سی و اسمبلی استفاده می‌کند تعریف می‌کنم. این با برنامه‌نویسی سطح بالا- که در اپلیکیشن‌های فضای کاربر متداول است و از زبان‌هایی چون پایتون و جاوا استفاده می‌کند- متفاوت است. 40 | 41 | - [ویکیپدیا-زبان برنامه‌نویسی سطح پایین](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) 42 | 43 | بلی برنامه‌نویسی سیستم مفهومی است مشابه برنامه‌نویسی سطح پایین. این صفحه طراحی سخت‌افزار و توسعه ثابت‌افزار را در بر می‌گیرد، مفاهیمی که جزو مباحث برنامه‌نویسی سیستم نیستند. 44 | 45 | - [ویکیپدیا-برنامه‌نویسی سیستم](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) 46 | سرانجام، این صفحه موضوعاتی همچون اجزای سخت‌افزاری و هسته لینوکس را 47 | شامل می‌شود. این گستره وسیعی از لایه‌هاست و یک مطلب یک صفحه‌ای 48 | نمی‌تواند جزئیات تمام این لایه‌ها را پوشش دهد بنابراین این مطلب می‌کوشد تا 49 | نقطه شروعی برای یادگیری برنامه‌نویسی سطح پایین باشد. 50 | 51 | **تئوری** 52 | ------------------------------------------------------------- 53 | دو تئوری زمینه‌ای در مورد برنامه‌نویسی سطح پایین وجود دارند: 54 | - معماری کامپیوتر 55 | - سیستم‌های عامل 56 | 57 | فکر می‌کنم بهترین راه برای یادگیری تئوری شرکت در دوره‌های آموزشی است. 58 | خواندن کتاب راه بدی نیست ولی نیازمند زمان و تلاش زیادی است. شما می‌توانید کلاس‌های خوب زیادی در دانشگاه‌های آنلاین پیدا کنید. بعنوان مثال Coursera.org و edx.org. فکر نمی‌کنم نیازی به گرفتن نمره الف داشته باشید، فقط تصویر کلی را متوجه شوید. با کسب تجربه بهتر و بهتر خواهید شد. 59 | 60 | اجازه بدهید چند کتاب را که خوانده‌ام به شما معرفی کنم. این کتاب‌ها معمولا در دانشگاه‌ها بعنوان کتاب تکست استفاده می‌شوند. اگر این کتاب‌ها در کلاس‌های دانشگاهتان تدریس نمی‌شوند، خواندن آنها خالی از لطف نخواهد بود. 61 | 62 | - معماری کامپیوتر 63 | - معماری کامپیوتر، چاپ پنجم: دیدگاه کمی 64 | - سیستم‌های کامپیوتری: از دید یک برنامه‌نویس 65 | - سازماندهی و طراحی کامپیوتر، جلد چهارم: رابط سخت‌افزار-نرم‌افزار 66 | - سیستم‌های عامل 67 | - توضیح باغ جادویی: درون یونیکس، سیستم ۵، چاپ۴، طراحی یک سیستم باز 68 | - طراحی سیستم عامل یونیکس 69 | - سیستم‌های عامل: اصول طراحی و اجزاء درونی توسط ویلیام استالینگ 70 | - دوره‌های آموزشی: 71 | 72 | - [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94) 73 | 74 | لیست نامحدودی از کتاب‌های خوب وجود دارد. قصد ندارم بگوییم که باید کتاب‌های زیادی بخوانید . فقط یک کتاب را به دقت بخوانید. وقتی که یک تئوری را یاد گرفتید، کد مربوط به آن را اجرا کنید. اجرای یک چیز بهتر از یاد گرفتن صدها تئوریست. 75 | 76 | **زبان‌ها:** 77 | --------------------------------------------------------------- 78 | **اسمبلی:**یک اسمبلی از میان x86 یا ARM انتخاب کنید. نیازی به دانستن هر دو نیست، در مجموع نیازی به دانستن زبان اسمبلی نیست بلکه هدف درک ساختار درونی پردازشگر و کامپیوتر است. بنابراین نیازی نیست که اسمبلی جدیدترین پردازشگر را یاد بگیرید.از بین ۸۰۸۶ و Corex-M یکی را انتخاب کنید. 79 | 80 | - [اسمبلی ۸۰۸۶ با emu8086](https://github.com/gurugio/book_assembly_8086) 81 | - مفاهیم پایه‌ای پردازشگر و معماری کامپیوتر 82 | - مفاهیم پایه‌ای زبان سی 83 | - [اسمبلی ۶۴ بیت(در حال ترجمه)](https://github.com/gurugio/book_assembly_64bit) 84 | - مفاهیم پایه‌ای پردازشگر مدرن و معماری کامپیوتر 85 | - مفاهیم پایه‌ای پیاده کردن و رفع اشکال کد سی 86 | - نیاز به کمک برای ترجمه 87 | - [یادگیری اسمبلی برای لینوکس-x64](https://github.com/0xAX/asm) 88 | - اسمبلی ۶۴ بیت با NASM و اسمبلی روی خط با GCC 89 | - [راهنمای معماری ARM ، چاپ دوم](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 90 | - منبع کامل برنامه‌نویسی ARM 91 | - سازماندهی و طراحی کامپیوتر 92 | - [ورژن MIPS](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 93 | - [ورژن ARM ](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 94 | - [ورژن RISC-V](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 95 | - کتاب‌های آکادمیکی که درباره نحوه کارکرد تمام اجزای کامپیوتر توضیح می‌دهند. 96 | - با طرح جزئیات درباره مفاهیم مختلف تشکیل دهنده معماری کامپیوتر توضیح می‌دهند. 97 | - این منابع برای کسانی که قصد دارند با جزئیات یک زبان اسمبلی خاص آشنا شوند مناسب نیستند. 98 | - ورژن‌های MIPS و ARM موضوعات مشابه را در قالب دو معماری مختلف پوشش می‌دهند. 99 | 100 | - هر دو ورژن شامل مثال‌هایی در مورد x86 هستند. 101 | 102 | **زبان سی:** 103 | میانبری وجود ندارد. کل کتاب را خوانده و تمام تمرینات را حل کنید. 104 | - [زبان سی: نگرشی نو، چاپ دوم](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 105 | - [زبان برنامه‌نویسی سی، چاپ دوم](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN) 106 | - [سی مدرن](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf) 107 | - برای استاندارد جدید سی 108 | - [آیا برنامه‌نویسی موازی سخت است؟ اگر بلی چه می‌توان کرد؟](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html) 109 | - پیاده‌سازی هم‌زمان‌سازی با سی 110 | - ضروری برای سی در سطح کلان(خصوصا برای برنامه‌نویسی هسته) 111 | - [دوره آموزشی سی بر پایه پروژه؟](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 112 | - اگر یک یا دو کتاب درباره سی خواندید، باید کار عملی انجام دهید . 113 | - چیزی را که دوست دارید انتخاب کنید. 114 | -ابتدا کد خود را بنویسید و آنرا با کد کس دیگری مقایسه کنید. تنها زمانی می‌توانید مهارتتان را بهبود ببخشید که کد سایرین را بخوانید و روش‌های بهتری یاد بگیرید. کتاب‌ها ایستا هستند ولی کد همواره در حال تغییر است. 115 | - [پروژه‌های مرتبط با سی و سایر زبان‌ها](https://github.com/danistefanovic/build-your-own-x) 116 | - پروژه‌های جذاب دیگری پیدا کنید. 117 | -[کتاب سیاه برنامه‌نویسی گرافیکی میشل ابرش، چاپ ویژه](http://www.jagregory.com/abrash-black-book/) 118 | 119 | - منبعی درباره بهینه‌سازی با استفاده از سی و مقداری اسمبلی. 120 | - از اسمبلی ۸۰۸۸ تا کنون را در بر می‌گیرد. 121 | - با تمرکز ویژه بر روی بهینه‌سازی گرافیکی سطح پایین. 122 | - [طراحی افزایه و چارچوب در سی](https://github.com/gurugio/book_cprogramming) 123 | - چگونه چارچوب و افزایه را با سی و در سطح وسیع گسترش دهیم؟ 124 | - نکاتی بسیار ابتدایی برای خواندن منبع هسته لینوکس. 125 | 126 | اگر قصد دارید در سی تبحر پیدا کنید به سایت [https://leetcode.com/](https://leetcode.com/)مراجعه کنید. 127 | 128 | **کاربردها** 129 | ------------------------------------------------------------- 130 | **سخت‌افزار و ثابت‌افزار:** 131 | اگر می‌خواهید مهندس سیستم‌های نهفته شوید شروع با یک کیت سخت‌افزاری ساده گزینه بهتری از جدیدترین تراشه ARM است. 132 | 133 | - [کیت آغازین آردوئینو](https://www.arduino.cc/) 134 | - سری‌های بسیاری از آردوئینو وجود دارند ولی کیت آغازین آردوئینو ساده‌ترین پردازشگر(Atmega328P) را داشته و کتاب راهنما هم دارد. 135 | - پردازشگر Atmega328P یک هسته هشت بیتی دارد که بستر مناسبی برای طراحی مدارهای دیجیتال و توسعه ثابت‌افزار فراهم می‌کند. 136 | - نیازی به دانستن طراحی شماتیک و اسمبل کردن تراشه نیست. 137 | - ولی باید بتوانید شماتیک‌ها را خوانده و متوجه شوید تراشه‌ها چگونه متصل می‌شوند. 138 | - توسعه‌دهندگان ثابت‌افزار باید بتوانند شماتیک‌ها را خوانده و بدانند چطور داده را به درایور مقصد بفرستند. 139 | - کتب راهنما را دنبال کنید. 140 | - [راهنمای ۸۰۸۶](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 141 | - اگر در معماری 86× مبتدی هستید، ۸۰۸۶ نیز راهنمای خوبی برای معماری پردازشگر و اسمبلی ۸۶×۸۰ خواهد بود. 142 | - [راهنمای ۸۰۳۸۶](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 143 | - بهترین راهنما برای مدل محافظت شده و مکانیسم پردازشگر ۸۶×۸۰. 144 | - ورژن وب:[https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm](https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm) 145 | 146 | در این مرحله باید بقدری پیشرفت کرده باشید که بتوانید پردازشگرهای ARM یا 86× را شروع کنید. 147 | - [https://www.raspberrypi.org/](https://www.raspberrypi.org/) 148 | - [https://beagleboard.org/](https://beagleboard.org/) 149 | - [https://www.arduino.cc/en/ArduinoCertified/IntelEdison](https://www.arduino.cc/en/ArduinoCertified/IntelEdison) 150 | 151 | برای مثال بورد رسپ‌بری پای پردازشگری با کورتکس-a53 دارد که مجموعه دستورات ۶۴ بیت را ساپورت می‌کند. این به شما امکان آشنا شدن با پردازشگر مدرن RPi را می‌دهد. شما می‌توانید آنرا بخرید ولی می‌خواهید چه کاری با آن انجام دهید؟ اگر برنامه خاصی ندارید احتمالا آنرا همانند سایر وسایلی که احتمالا قبلا خریده‌اید در کشو انداخته و فراموش خواهید کرد. 152 | بنابراین من یک پروژه به شما پیشنهاد می‌کنم: 153 | 154 | - [ساختن یک کرنل](http://wiki.osdev.org/Getting_Started) 155 | - چند منبع خوب: [https://www.reddit.com/r/osdev/](https://www.reddit.com/r/osdev/) 156 | - [یادگیری گسترش سیستم عامل با استفاده از هسته لینوکس و رسپ‌بری پای](https://github.com/s-matyukevich/raspberry-pi-os) 157 | - (توصیف پروژه): این منبع حاوی یک راهنمای گام به گام است که نحوه ساختن هسته یک سیستم عامل ساده را از ابتدا نشان می‌دهد. هر مبحث طوری طراحی شده است که نشان می‌دهد که یک کارکرد هسته در سیستم عامل RPi چطور پیاده می‌شود و سپس نحوه عمل همان کارکرد در هسته لینوکس را نشان می‌دهد. 158 | 159 | من یک [ شبه هسته](https://github.com/gurugio/caos) ساخته‌ام که مدل ۶۴ بیت، پیجینگ و جابجایی ساده موضوع را ساپورت می‌کند. ساختن چنین هسته‌ای کمک می‌کند تا با معماری کامپیوتر‌های نوین و کنترل سخت‌افزار آشنا شوید. 160 | 161 | در واقع شما تا به اینجا جدیدترین پردازشگرها و سخت‌افزار را بواسطه لپ‌تاپ و دسک‌تاپتان در اختیار دارید. در حقیقت تمام چیزهای مورد نیاز برای شروع در دسترستان هستند و نیاز به خرید چیزی ندارید. برابرساز کمو می‌تواند برای پردازشگر ARM و اینتل برابرسازی کند. بنابراین تمام چیزهای مورد نیاز در اختیارتان هستند. هسته‌ها و مطالب زیادی وجود دارند که شما می‌توانید از آنها استفاده کنید. برابرساز کمو را نصب کرده و یک هسته کوچک که بوت می‌شود، صفحه‌بندی را فعال می‌کند و چند پیام را چاپ می‌کند بسازید. 162 | 163 | سایر هسته‌ها: 164 | - [https://littleosbook.github.io/](https://littleosbook.github.io/) 165 | - [https://littleosbook.github.io/](https://littleosbook.github.io/) 166 | 167 | **هسته لینوکس و درایور** 168 | نیازی به ساختن یک سیستم عامل کامل ندارید.به انجمن لینوکس پیوسته و در توسعه آن شرکت کنید. 169 | 170 | منابعی برای هسته لینوکس و درایور از مبتدی تا پیشرفته، 171 | - کتاب‌ها: این کتاب‌ها را به‌ترتیب بخوانید: 172 | - [طراحی سیستم عامل لینوکس](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 173 | - مفاهیم پایه‌ای لینوکس در تمامی سیستم‌های عامل استفاده می‌شوند. 174 | - این کتاب منبع مناسبی برای درک مفاهیم بنیادی سیستم‌های عامل است. 175 | - [درایورهای لینوکس](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) 176 | - تمام مثال‌ها را برای خودتان بسازید. 177 | - [توسعه هسته لینوکس](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) 178 | - طراحی هسته لینوکس را درک کنید. 179 | - [متوجه شدن هسته لینوکس](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) 180 | 181 | - این کتاب و منبع هسته V2.6‍‍‍ را بطور همزمان بخوانید. 182 | - هیچگاه با آخرین ورژن شروع نکنید، V2.6 کافی است. 183 | - برای اجرای خط به خط منبع هسته از کمو و جی دی بی استفاده کنید. 184 | 185 | [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) 186 | [https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md](https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md) 187 | -از بیزی‌باکس برای ساختن ساده‌ترین سیستم فایل‌بندی استفاده کنید که در مدت یک ثانیه بالا می‌آید. 188 | - [https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md](https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md) 189 | - سایر منابع:منابع رایگانی که توصیه می‌کنم: 190 | - آزمایشگاه درایور‌های لینوکس. 191 | - راهنمای عملی و تمرینات عالی برای ساختن درایورهای لینوکس به‌همراه ای‌پی‌آی‌های ضروری هسته. 192 | - [چالش یودوپتولا](http://eudyptula-challenge.org/) 193 | 194 | - متاسفانه این چالش اعضای جدیدی نمی‌پذیرد، چون چالش جدیدی وجود ندارد. نگهدارنده سایت گفته است که در حال کار بر روی یک فرمت جدید است. امیدوارم که شاهد بازگشت این چالش باشیم. 195 | - شما می‌توانید سوالات مربوطه را در گوگل سرچ کنید. سعی کنید سوالات را حل کنید و پاسخ را با جواب‌های موجود مقایسه کنید. 196 | - این مشابه یک معلم خصوصی است که شما را راهنمایی می‌کند. 197 | - اگر نمی‌دانید چه کنید این را شروع کنید. 198 | - [یادگیری توسعه سیستم عامل با استفاده از هسته لینوکس و رسپ‌بری پای](https://github.com/s-matyukevich/raspberry-pi-os) 199 | 200 | - این پروژه هنوز کامل نشده است. 201 | - همواره بر این عقیده هستم که ساختن هسته‌ای مشابه هسته لینوکس بهترین راه برای یادگیری هسته لینوکس است. 202 | - لایه بلاک و درایور دستگاه: 203 | - از یک بلاک ساده درایور(مثلا رام‌دیسک) با مدل چند صفی شروع کنید. 204 | - جلوتر رفته و به لایه بلاک بروید. 205 | - ترجمه انگلیسی را تمام کردم، لطفا نظر خود را برایم بفرستید. 206 | - [درایور ام‌دی برای لینوکس(کره‌ای)](https://github.com/gurugio/book_linuxkernel_md) 207 | - ابزار mdadm چطور کار می‌کند و چطور درایورmd را فرامی‌خواند؟ 208 | - درایور md چطور کار می‌کند؟ 209 | 210 | **منابع** 211 | 212 | وقتی به چیزی نیاز دارید آنرا چک کنید. 213 | 214 | - [صفحه الکترون آزاد](http://free-electrons.com/docs/) 215 | - فایل‌های اسلاید متعددی که موضوعات خوبی همچون لینوکس ARM را معرفی می‌کنند. 216 | -[پست جولیا ایوان: شما می‌توانید یک هکر هسته باشید](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 217 | - راهنمایی برای برنامه‌نویسی هسته. 218 | 219 | **سایر اپلیکیشن‌ها** 220 | شاید شما به لینوکس و ثابت‌افزار علاقه نداشته باشید. در اینصورت می‌توانید 221 | اپلیکیشن‌های دیگری پیدا کنید: 222 | - برنامه‌نویسی سیستمی و درایور لینوکس. 223 | - ایمنی. 224 | - مهندسی معکوس. 225 | من درباره این اپلیکیشن‌ها اطلاعی ندارم. لطفا هر نوع اطلاعات مبتدی در این زمینه دارید برایم بفرستید. 226 | 227 | برنامه‌نویسی سطح پایین به هسته و درایورها محدود نمی‌شود. یکی دیگر از کاربردهای این نوع برنامه‌نویسی ذخیره نرم‌افزاری یا سیستم فایل‌بندی توزیع شده است. 228 | 229 | - دوره آموزشی: [https://pdos.csail.mit.edu/archive/6.824-2012/](https://pdos.csail.mit.edu/archive/6.824-2012/) 230 | - منبع: [ https://github.com/srned/yfs](https://github.com/srned/yfs) 231 | 232 | **آینده برنامه‌نویسی سطح پایین** 233 | -------------------------------------------------------------- 234 | 235 | درباره آینده چیزی نمی‌دانم ولی نگاهم را به راست(Rust) دوخته‌ام. 236 | - [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/) 237 | 238 | اگر یک هفته آزاد و تنها بودم، راست را یاد می‌گرفتم چون این تنها زبان جدیدیست که می‌توانم با آن درایور لینوکس بسازم. 239 | - [https://github.com/tsgates/rust.ko](https://github.com/tsgates/rust.ko) 240 | 241 | یوت(IoT) شیوه جدیدی است, بنابراین می‌توانید بررسی کنید که چه سیستم‌های عاملی برای آن مناسب هستند.ARM، سامسونگ و برخی از کمپانی‌های دیگر سیستم‌های عامل بی‌درنگ خود را دارند ولی متاسفانه بسیاری از آنها منبع بسته هستند. ولی بنیاد لینوکس یک راه حل دارد: زفیر. 242 | 243 | - [https://www.zephyrproject.org/](https://www.zephyrproject.org/) 244 | 245 | سرورهای ابری متداوال لایه‌های گوناگونی دارند؛ مثلا سیستم عامل میزبان، درایور KVM، پروسه کمو، سیستم عامل میهمان و سرویس‌های اپلیکیشن. یک مخزن هم برای فراهم کردن مجازی‌سازی سبک ایجاد شده است. در آینده نزدیک مفهومی جدید از سیستم عامل، یک به اصطلاح سیستم عامل کتابخانه‌ای یا تک هسته‌ای جایگزین منبع نرم‌افزار برای مجازی‌سازی خواهد شد. 246 | 247 | - [http://unikernel.org/](http://unikernel.org/) 248 | داده‌های بزرگ و رایانش ابری پیوسته نیاز به فضای ذخیره‌سازی بزرگ‌تری دارند. برخی از دیسک‌هایی که مستقیما به سرورها وصل هستند نمی‌توانند پاسخگوی ظرفیت، ثبات و عملکرد مورد نیاز باشند. بنابراین تحقیقاتی برای ایجاد سیستم‌های ذخیره‌سازی بسیار بزرگ انجام شده‌اند که ماشین‌های ذخیره‌سازی متعددی را توسط شبکه پرسرعت متصل می‌کنند. اینها در گذشته بر ساخت یک حجم ذخیره بسیار بزرگ متمرکز بودند ولی در حال حاضر حجم‌های متعددی که به ماشین‌های مجازی مختلفی اختصاص داده شده‌اند فراهم شده‌اند. 249 | - [https://en.wikipedia.org/wiki/Software-defined_storage](https://en.wikipedia.org/wiki/Software-defined_storage) 250 | - [https://en.wikipedia.org/wiki/Clustered_file_system](https://en.wikipedia.org/wiki/Clustered_file_system) 251 | - [https://en.wikipedia.org/wiki/Ceph_(software)](https://en.wikipedia.org/wiki/Ceph_(software)) 252 | 253 | 254 | **چطور شروع کنیم؟** 255 | ---------------------------------------------------------- 256 | 257 | ایمیلی دریافت کردم که پرسیده بود چگونه شروع کنیم. در این صفحه اطلاعات زیادی درباره درباره کتاب‌ها، دوره‌های آموزشی و پروژه‌ها وجود دارند. اشتباه من بود که توضیح درباره چگونه شروع کردن را فراموش کردم.متاسفانه هیچ راه آسانی برای رسیدن به [کینگ‌لندینگ](https://gameofthrones.fandom.com/wiki/King%27s_Landing) وجود ندارد و من به توضیح اینکه خودم چگونه شروع کردم می‌پردازم. اگر تا کنون کاری انجام داده‌اید لطفا از این بخش عبور کنید. این تنها مثالی است که به شما می‌آموزد که برای شروع چکار کنید. 258 | 259 | - خواندن کتاب‌های سیستم عامل: حداقل کتاب *طراحی سیستم عامل لینوکس* نوشته موریس جی باخ را بخوانید. 260 | - اسمبلی و سی را یاد بگیرید. 261 | - [اسمبلی ۸۰۸۶ با امو ۸۰۸۶](https://github.com/gurugio/book_assembly_8086) 262 | - یادگیری مفاهیم اسمبلی کافیست و نیازی به انجام کار عملی ندارید. 263 | - [زبان برنامه‌نویسی سی، چاپ دوم](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628/ref=pd_sbs_14_t_0?_encoding=UTF8&psc=1&refRID=60R1D2CHBA8DHYT6JNMN) 264 | - سعی کنید که تمام تمرینات این کتاب را حل کنید. 265 | - [برنامه‌نویسی سی، نگرشی نوین،‌چاپ دوم](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 266 | - کاری عملی با سی انجام دهید. 267 | -[خودآموزهای پروژه‌محور سی](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 268 | - یک یا دو پروژه جذاب انتخاب کنید و پروژه خودتان را بسازید. 269 | -سایت[leetcode.com](https://leetcode.com/): اگر نمی‌توانید پروژه مناسبی انتخاب کنید، ساختمان داده و الگوریتم می‌توانند گزینه‌های مناسبی باشند. 270 | - پروژه‌ای در زمینه سخت‌افزار انجام دهید. 271 | - رسپ‌بری پای و آردوئینو اهمیت چندانی ندارند. باید تجربه کنترل سخت‌افزار با سی را داشته باشید، فقط با سی! 272 | - توصیه می‌کنم یک کیتAtmega128 خریده و ثابت‌افزاری بسازید که ال‌سی‌دی ها را خاموش و روشن می‌کند. ورودی سوئچ و پیام نشان داده شده روی ال‌سی‌دی را ردیابی کنید. برنامه کنترل حرکت هم پروژه خوبی خواهد بود. بعنوان مثال ردیاب خط. 273 | - از کتابخانه استفاده نکنید. باید همه چیز غیر از دانلود کننده برنامه را خودتان بسازید. 274 | - مبانی هسته لینوکس. 275 | - برنامه‌نویسی سطح پایین بسیار به سیستم عامل نزدیک است. باید با درون سیستم عامل آشنایی داشته باشید. 276 | - با درایورها شروع کنید. 277 | - [درایورهای لینوکس را بخوانید](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) 278 | -[آزمایشگاه درایورهای لینوکس](https://linux-kernel-labs.github.io/) 279 | - [چالش یودوپتولا](http://eudyptula-challenge.org/) 280 | - کتاب [توسعه هسته لینوکس](http://eudyptula-challenge.org/) را بخوانید. 281 | 282 | - وارد زمینه حرفه‌ای شوید. 283 | - اگر می‌خواهید توسعه دهنده حرفه‌ای هسته لینوکس شوید. 284 | - باید کتاب[درک هسته لینوکس](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 285 | ) 286 | را بخوانید. 287 | - سپس تلاش کنید یک شبه هسته بسازید. 288 | - [یادگیری توسعه سیستم عامل با استفاده از هسته لینوکس و رسپ‌بری‌پای](https://github.com/s-matyukevich/raspberry-pi-os) 289 | - [هسته خودتان را بسازید](http://wiki.osdev.org/Getting_Started) 290 | - به [https://lwn.net/](https://lwn.net/)بپیوندید و آخرین مسائل را دنبال کنید. 291 | - یا موضوع دیگری پیدا کنید. 292 | 293 | **ترجمه** 294 | ------------------------------------------------------------- 295 | - اگر قصد ترجمه این صفحه را دارید، لطفا برایم تقاضا بفرستید. آن را به این لیست اضافه خواهم کرد. 296 | 297 | - [Chinese(Traditional)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tw.md) 298 | - [Chinese(Simplified)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md) 299 | - [Portuguese (Brazilian)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md) 300 | - [Italian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md) 301 | - [Czech](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md) 302 | - [Russian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md) 303 | - [Turkish](https://github.com/masscollaborationlabs/lowlevelprogramming-university/blob/master/README_tr.md) 304 | 305 | **درباره مولف** 306 | --------------------------------------------------------- 307 | از مطلب [google-interview-university](https://github.com/jwasham/google-interview-university) الهام گرفته‌ام. تمایل دارم تجاربم را به اشتراک بگذارم و راه تبدیل شدن به یک برنامه‌نویس سطح پایین را نشان دهم زیرا دریافته‌ام که این مهارت‌ها باندازه سابق محبوبیت ندارند. بعلاوه بسیاری از دانشجویان درباره اینکه چطور می‌توان یک مهندس هسته لینوکس شد می‌پرسند. 308 | 309 | من بیش از ده سال تجربه در زمینه برنامه‌نویسی سطح پایین دارم: 310 | - اسمبلی ۸۶×۸۰ 311 | - سخت‌افزار با تراشه و ثابت‌افزار Atmel 312 | - برنامه‌نویسی سیستمی سی برای لینوکس 313 | - درایور لینوکس 314 | - هسته لینوکس: تخصیص صفحه 315 | - هسته لینوکس: درایور بلاک و مودول ام‌دی 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 |
326 | -------------------------------------------------------------------------------- /README_id.md: -------------------------------------------------------------------------------- 1 | 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. 2 | 3 | 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. 4 | 5 | CATATAN3: Jika anda ingin langsung mulai, silahkan ke bagian "How to start?". 6 | 7 | * [Low-Level Programming University](#Low-Level-Programming-University) 8 | * [Apa itu?](#What-is-it) 9 | * [Apa yang dimaksud dengan Low-Level?](#What-Is-the-Low-Level) 10 | * [Teori](#Theory) 11 | * [Bahasa](#Languages) 12 | * [Assembly](#Assembly) 13 | * [Bahasa C](#C-language) 14 | * [Bahasa Rust](#Rust-language) 15 | * [Pengaplikasian](#Applications) 16 | * [Perangkat Keras && Firmware](#Hardware-Firmware) 17 | * [Linux kernel and device driver](#Linux-kernel-and-device-driver) 18 | * [Referensi](#References) 19 | * [Pengaplikasian lain](#Other-applications) 20 | * [Masa depan pemrograman tingkat rendah](#Future-of-low-level-programming) 21 | * [Cara memulai?](#How-to-start) 22 | * [Terjemahan](#Translation) 23 | * [Tentang Saya?](#who-am-i) 24 | 25 | # Low-Level Programming University 26 | 27 | ## Apa itu? 28 | 29 | 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. 30 | 31 | 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. 32 | 33 | Pemrograman Low-level adalah bagian dari ilmu komputer. 34 | Tentu saja akan lebih baik untuk memperoleh edukasi di ilmu komputer terlebih dahulu. 35 | * [Jalan menuju pendidikan otodidak gratis di bidang Ilmu Komputer!](https://github.com/ossu/computer-science) 36 | 37 | 38 | ## Apa yang dimaksud dengan Low-Level? 39 | 40 | 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). 41 | * [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language) 42 | 43 | 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. 44 | * [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming) 45 | 46 | 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. 47 | 48 | ## Teori 49 | 50 | Ada dua latar belakang teori pada pemrograman low-level: 51 | * Arsitektur Komputer 52 | * Sistem Operasi 53 | 54 | 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. 55 | 56 | 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. 57 | * Arsitektur Komputer 58 | * Computer Architecture, Fifth Edition: A Quantitative Approach 59 | * Computer Systems: A Programmer's Perspective 60 | * Computer Organization and Design, Fourth Edition: The Hardware/Software Interface 61 | * Sistem Operasi 62 | * The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design 63 | * The Design of the UNIX Operating System 64 | * Operating Systems: Internals and Design Principles by William Stallings 65 | * Course yang Direkomendasikan 66 | * [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94) 67 | * Keterampilan Pemrograman Umum 68 | * [Structure and Interpretation of Computer Programs](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs) 69 | * 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). 70 | * Jika anda mempelajari Lisp/Scheme, anda seharusnya sudah bisa belajar bahasa lain dengan cepat. 71 | * [Saya telah menyelesaikan sekitar 80% latihan. Dianjurkan untuk mencoba setiap latihan yang ada](https://github.com/gurugio/sicp_exercise) 72 | * Perancangan Perangkat Keras 73 | * Membangun 8086 Microprocessor Kit Anda Sendiri 74 | * Jika anda tidak membangun papan HW (Hardware) anda sendiri, anda tidak memahami apa itu perangkat yang dipetakan memori fisik. 75 | * AP modern memuat banyak sekali IP. Jadi anda tidak memiliki kesempatan untuk memahami bagaimana inti CPU dan perangkat periferal dihubungkan. 76 | * 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. 77 | * 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. 78 | * Coba ketik di Google "8086 kit". Anda seharusnya akan bisa menemuan beberapa situs web dimana anda bisa membeli sebuah skema HW, parts, dah panduannya. 79 | 80 | 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** 81 | 82 | ## Bahasa 83 | 84 | ### Assembly 85 | 86 | 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. 87 | 88 | * [8086 pemrograman assembly dengan emu8068](https://github.com/gurugio/book_assembly_8086) 89 | * konsep-konsep dasar CPU dan arsitektur komputer 90 | * konsep-konsep dasar bahasa pemrograman C 91 | * [pemrograman assembly 64bit (terjemahan sedang dalam pengerjaan)](https://github.com/gurugio/book_assembly_64bit) 92 | * konsep-konsep dasar CPU modern dan arsitektur komputer 93 | * konsep-konsep dasar pembongkaran dan debugging kode C 94 | * _perlu bantuan untuk penterjemahan_ 95 | * [Belajar assembly untuk linux-x64](https://github.com/0xAX/asm) 96 | * pemrograman assembly 64-bit murni dengan NASM dan inline assembly dengan GCC 97 | * [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 98 | * Referensi lengkap pada pemrograman ARM 99 | * Organisasi dan Perancangan Komputer 100 | * [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 101 | * [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 102 | * [RISC-V Edition](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 103 | * Buku-buku akademis yang menjelaskan bagaimana tiap komponen dari sebuah komputer bekerja dari awal. 104 | * Penjelasan detil perbedaan konsep-konsep yang membentuk arsitektur komputer. 105 | * Buku tersebut tidak menargetkan ke para pembaca yang mengharapkan untuk mahir di bahasa assembly yang spesifik. 106 | * Edisi MIPS dan ARM mencakup topik-topik yang sama tapi membedah arsitektur yang berbeda. 107 | * Kedua edisi tersebut mengandung contoh-contoh di dunia x86. 108 | 109 | ### Bahasa C 110 | 111 | Tidak ada jalan pintas. Baca saja seluruh isi buku dan selesaikan semua latihan. 112 | 113 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 114 | * [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) 115 | * Modern C: Jens Gustedt. Modern C. Manning, 2019, 9781617295812. ffhal-02383654f 116 | * Untuk standar C yang baru 117 | * [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) 118 | * implementasi mentah sinkronisasi dengan C 119 | * Sangat diperlukan untuk pemrograman C skala besar (terutama untuk pemrograman kernel) 120 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 121 | * Jika anda selesai membaca satu atau dua buku pemrograman C, kamu HARUS membuat sesuatu. 122 | * Pilih yang manapun yang anda sukai. 123 | * 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. 124 | * [C and other languages based projects](https://github.com/danistefanovic/build-your-own-x) 125 | * temukan proyek-proyek menarik lainnya 126 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 127 | * Referensi optimisasi menggunakan C dan sedikit x86 assembly 128 | * Mulai dari 8088 hingga saat ini 129 | * Berfokus khusus pada optimisasi grafik tingkat rendah 130 | * [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming) 131 | * Cara mengembangkan framework dan plugin di C pada perangkat lunak skala besar 132 | * Tips-tips pemrograman yang sangat mendasar untuk membaca sumber kernel Linux 133 | 134 | Jika anda ingin menjadi ahli pemrograman C, kunjungi https://leetcode.com/. Semoga beruntung! 135 | 136 | ### Bahasa Rust 137 | 138 | Saya meyakini bahwa bahasa pemrograman selanjutnya untuk pemrograman sistem adalah Rust. 139 | Saya akan membuat daftar apa yang saya lakukan untuk belajar Rust. 140 | 141 | [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/) 142 | 143 | * [The Rust Programming Language](https://doc.rust-lang.org/book/) 144 | * Pengenalan yang bagus, namun kurang akan contoh dan latihan-latihan. 145 | * [Rust by Example](https://doc.rust-lang.org/rust-by-example/) 146 | * Ketika membaca "The Rust Programming Language", anda bisa menemukan contoh dan latihan-latihan di sini. 147 | * Namun tidak banyak latihan yang bisa Anda lakukan sendiri. Hanya beberapa contoh termasuk latihan "lakukan ini" dan latihan tersebut sangat mudah. 148 | * [Programming Rust, 2nd](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/) 149 | * Pengenalan yang lebih dalam, namun masih kurang akan contoh dan latihan-latihan. 150 | * [Exercism](https://exercism.org/tracks/rust) 151 | * Latihan-latihan yang bagus untuk melatih fitur individu dari RUST. 152 | * Saya tidak yakin para mentor bekerja secara aktif namun itu seharusnya cukup untuk membandingkan solusi anda dengan solusi lain. 153 | * Setelah mengirimkan solusi anda, anda bisa melihat solusi orang lain dengan tab "Community solutions" (sejak Exercism V3). 154 | * Banyak latihan-latihan dengan level mudah adalah untuk fitur fungsional seperti map/filter/any dan lain-lain. 155 | * [Easy rust](https://dhghomon.github.io/easy_rust/) 156 | * Sebuah buku yang ditulis dengan bahasa inggris yang mudah. 157 | * Bahan ajar youtubed yang tersedia: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk 158 | * [Let's get rusty](https://www.youtube.com/c/LetsGetRusty) 159 | * Banyak Youtuber mengunggah kursus Rust namun saya paling menikmati kursus ini. 160 | * Dia telah mengunggah berita terbaru untuk Rust. Layak untuk disubscribe. 161 | * [Rust for Linux](https://github.com/Rust-for-Linux) 162 | * Lihat sumber-sumber contoh dan cek bagaimana Rust akan masuk ke kernel Linux 163 | 164 | ## Pengaplikasian 165 | 166 | ### Hardware && Firmware 167 | 168 | Jika anda ingin menjadi embedded system engineer, akan lebih baik untuk mulai dari sebuah hardware kit yang sederhana, daripada memulai dengan chipset ARM terbaru. 169 | 170 | * [Arduino Start Kit](https://www.arduino.cc/) 171 | * Ada banyak seri dari Arduino namun "Arduino Start Kit" yang punya prosesor(Atmega328P) dan buku panduan yang paling sederhana. 172 | * Atmega328P memiliki 8-bit inti yang mana membuatnya jadi permulaan yang bagus untuk perancangan sirkuit digital dan pengembangan firmware. 173 | * Anda tidak perlu tahu cara menggambar skema dan tata letak serta merakit chip. 174 | * Namun anda perlu tahu cara membaca skema dan memahami bagaimana chip saling terhubung. 175 | * Pengembang firmware seharusnya tahu cara membaca skema dan mencari tahu cara mengirim data ke perangkat target. 176 | * Ikuti buku panduan! 177 | * [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 178 | * Jika anda pemula pada arsitektur x86, 8086 juga panduan yang sangat bagus untuk arsitektur prosesor dan assembly 80x86 179 | * [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 180 | * Panduan terbaik untuk mode terproteksi dan mekanisme paging prosesor 80x86 181 | * Versi web: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 182 | 183 | Pada titik ini, anda sebaiknya mulai dengan prosesor ARM dan x86 terbaru. 184 | * https://www.raspberrypi.org/ 185 | * https://beagleboard.org/ 186 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 187 | 188 | Sebagai contoh, board Raspberry Pi memiliki prosesor Cortex-A53 yang mendukung set instruksi 64-bit. 189 | Ini mengizinkan anda untuk merasakan arsitektur prosesor modern dengan rPi. 190 | Ya, anda bisa membelinya... namun... apa yang akan anda lakukan dengan itu? 191 | 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. 192 | 193 | Jadi, saya merekomendasikan satu proyek untuk anda. 194 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 195 | * Referensi bagus: https://www.reddit.com/r/osdev/ 196 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 197 | * (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. 198 | 199 | 200 | 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. 201 | 202 | Faktanya, Anda sudah memiliki prosesor terbaru dan perangkat keras terbaru. 203 | Laptop anda! Desktop anda! Anda telah memiliki semua yang anda perlukan untuk memulai! 204 | Anda tidak perlu membeli apapun. 205 | Emulator qemu dapat mengemulasi prosesor ARM dan prosesor Intel terbaru. 206 | Jadi segala yang anda perlukan sudah ada di tangan. 207 | Ada banyak kernel mainan dan dokumen yang dapat anda jadikan rujukan. 208 | Install saja emulator qemu dan buatlah sebuah kernel kecil yang hanya booting, mengaktifkan paging, dan print beberapa pesan. 209 | 210 | Kernel mainan lainnya: 211 | * https://littleosbook.github.io/ 212 | * https://tuhdo.github.io/os01/ 213 | 214 | ### Kernel Linux dan driver perangkat 215 | 216 | Anda tidak perlu untuk membuat sebuah sistem operasi yang lengkap. 217 | Bergabung ke komunitas Linux dan berpartisipasi di dalam pengembangan. 218 | 219 | Beberapa sumber untuk pengembangan kernel Linux dan driver perangkat dari tingkat pemula ke tingkat lanjut. 220 | * Buku-buku: Bacalah dalam urutan berikut 221 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 222 | * Konsep-konsep dasar dari Unix yang diaplikasikan ke dalam semua sistem operasi. 223 | * Buku ini adalah tempat yang sangat bagus untuk belajar konsep-konsep ini dari sistem operasi. 224 | * [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) 225 | * Kerjakan semua contoh-contoh untuk diri anda sendiri 226 | * [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) 227 | * Pahami perancangan kernel Linux 228 | * [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) 229 | * Baca buku ini dan sumber kernel v2.6 sekaligus 230 | * Jangan pernah memulai dengan versi terbaru, v2.6 sudah cukup! 231 | * Gunakan qemu dan gdb untuk menjalankan sumber kernel baris demi baris 232 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu 233 | * https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md 234 | * Gunakan busybox untuk membuat filesystem paling sederhana yang hanya butuh satu detik untuk booting 235 | * https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md 236 | * Sumber-sumber lain: Sumber gratis yang saya rekomendasikan 237 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 238 | * Panduan praktis dan latihan luar biasa membuat driver perangkat Linux dengan API kernel penting 239 | * Menurut saya dokumen ini memperkenalkan hampir semua API kernel esensial. 240 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 241 | * _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. 242 | * 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. 243 | * Ini seperti guru privat luar biasa yang memandu Anda tentang apa yang harus dilakukan. 244 | * Jika Anda tidak tahu harus berbuat apa, mulailah saja. 245 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 246 | * Proyek ini masih belum selesai. 247 | * Saya selalu berpikir membuat sebuah kernel yang mirip dengan kernel Linux adalah cara terbaik untuk memahami kernel Linux. 248 | * [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv) 249 | * mulai dari contoh driver perangkat blok sederhana (Ramdisk) dengan mode multi-queue 250 | * maju ke lapisan blok 251 | * Saya menyelesaikan penerjemahan ke bahasa inggris. Silakan kirimkan tanggapan Anda kepada saya. 252 | * [md driver of Linux kernel(Korean)](https://github.com/gurugio/book_linuxkernel_md) 253 | * bagaimana tool mdadm bekerja dan cara dia memanggil driver md 254 | * bagaimana driver md bekerja 255 | * [A Heavily Commemted Linux Kernel Source Code](http://www.oldlinux.org/) 256 | * Komentar berat untuk Linux kuno v0.12. 257 | * Sebaiknya memulai dengan OS yang lama dan sederhana. 258 | * 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) 259 | 260 | #### Referensi 261 | 262 | Periksa ketika anda memerlukan sesuatu 263 | 264 | * [Free-electrons homepage](http://free-electrons.com/docs/) 265 | * banyak file slide yang memperkenalkan topik-topik bagus, khususnya ARM-linux 266 | * [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 267 | * panduan untuk memulai pemrograman kernel 268 | 269 | ### Penerapan lain 270 | 271 | Ya, anda mungkin tidak tertarik pada Linux atau firmware. Jika begitu, anda bisa menemukan penerapan lain: 272 | * Pemrograman sistem Windows & driver-driver perangkat 273 | * Security 274 | * Reverse engineering 275 | 276 | Saya tidak memiliki pengetahuan apapun tentang penerapan-penerapan tersebut. Silahkan kirimkan saya informasi apapun untuk pemula. 277 | 278 | **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. 279 | * Course: https://pdos.csail.mit.edu/archive/6.824-2012/ 280 | * sumber referensi: https://github.com/srned/yfs 281 | 282 | ## Masa depan pemrograman tingkat rendah 283 | 284 | Saya tidak tahu masa depan, namun saya terus memperhatikans Rust. 285 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 286 | 287 | Jika saya bisa punya satu minggu bebas dan sendiri, saya akan belajar Rust. 288 | Itu dikarenakan Rust ada adalah bahasa terbaru yang dapat saya gunakan untuk mengembangkan driver perangkat Linux. 289 | * https://github.com/tsgates/rust.ko 290 | 291 | IoT adalah tren baru, jadi ada baikny cek OS apa untuk IoT. 292 | ARM, Samsung dan beberapa perusahaan memiliki realtime OS mereka masing-masing namun sayangnya banyak dari mereka adalah closed source. 293 | Tetapu Linux Foundation juga memiliki sebuah solusi: Zephyr 294 | * https://www.zephyrproject.org/ 295 | 296 | 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. 297 | * http://unikernel.org/ 298 | 299 | 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. 300 | * https://en.wikipedia.org/wiki/Software-defined_storage 301 | * https://en.wikipedia.org/wiki/Clustered_file_system 302 | * https://en.wikipedia.org/wiki/Ceph_(software) 303 | 304 | ## Bagaimana cara untuk memulai? 305 | 306 | 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. 307 | 308 | * Membaca buku-buku teori OS: setidaknya "The Design of the UNIX Operating System by Maurice J. Bach" 309 | * Belajar assembly dan C 310 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 311 | * Itu cukup jika anda mengerti konsep dari pemrograman assembly. Anda tidak perlu untuk melakukan sesuatu yang praktikal. 312 | * [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) 313 | * LAKUKAN YANG TERBAIK untuk menyelesaikan semua latihan! 314 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 315 | * Lakukan sesuatu yang praktikal dengan C 316 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/): Cari satu atau dua proyek menarik dan buat proyek anda sendiri. 317 | * [leetcode.com](https://leetcode.com/): Jika anda tidak bisa menemukan sebuah proyek yang menarik, sebaiknya juga fokus pada struktur data dan algoritma. 318 | * Lakukan proyek hardware 319 | * RaspberryPi atau Arduino tidak masalah. Anda memerlukan pengalaman untuk mengontrol hardware secara langsung dengan C. HANYA C! 320 | * Saya merekomendasikan untuk membeli sebuah kit Atmega128 dan buat sebuah firmware untuk mnghidupkan/mematikan LED, mendeteksi input switch dan menampilkan pesan pada LCD teks. Program kontrol motor juga proyek yang sangat bagus: contohnya, line tracer (pelacak garis). 321 | * JANGAN menggunakan library apapun. Anda harus membuat semuanya sendiri, kecuali pengunduh program. 322 | * Dasar dari kernel Linux 323 | * Pemrogaman tingkat rendah sangat dekat dengan sistem operasi. Anda harus tahu bagian dalam dari OS. 324 | * Mulailah dengan driver 325 | * Baca [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) 326 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 327 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 328 | * Baca [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) untuk memahami internal kernel Linux. 329 | * Terjun ke bidang profesional 330 | * Jika anda mau menjadi seorang Developer Kernel Linxu profesional 331 | * harus baca [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) 332 | * Lalu cobalah buat sebuah kernel mainan 333 | * [Learn operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 334 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 335 | * Tulis tautan github kernel anda pada resume (Jangan lupa untuk menulis deskripsi detail dalam commit message) 336 | * Cek issue terbaru di https://lwn.net/ dan bergabunglah. 337 | * Cek "Recent kernel patches" pada "https://lwn.net/Kernel/" atau tautan langsung https://lwn.net/Kernel/Patches 338 | * Temukan patch yang menarik untuk anda. Cobalah untuk memahami kode sumber. Tentu saja akan sangat sulit namun cobalah. Anda akan semakin dekat setiap kali anda mencobanya. 339 | * Bangun kernel dan tes di sistem anda. Contohnya, tes performa, tes stabilitas dengan LTP(https://linux-test-project.github.io/) atau tool static code analysis di dalam kernel. 340 | * Laporkan masalah apapun jika anda menemukan: compile warnings/errors, performance drop, kernel panic/oops atau masalah apapun 341 | * Jika bekerja dengan baik, laporkan itu dengan spesifikasi sistem anda, Pemilik patch akan menulis sebuah tag "Direview oleh" dengan nama anda. 342 | * Temukan nama anda pada git log kernel. 343 | * Atau temukan topik lainnya 344 | * Ada banyak bidang di mana low-level engineer bisa bekerja: security, Compiler, Firmware, robot/mobil dan sebagainya 345 | 346 | # Terjemahan 347 | 348 | Silahkan kirimkan saya pull request jika anda ingin menerjemahkan halaman ini. Saya akan mencantumkannya di sini. 349 | 350 | * [Chinese(Traditional)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tw.md) 351 | * [Chinese(Simplified)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md) 352 | * [Portuguese (Brazilian)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md) 353 | * [Italian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md) 354 | * [Czech](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md) 355 | * [Russian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md) 356 | * [Turkish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tr.md) 357 | * [Persian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fa.md) 358 | * [Spanish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_es.md) 359 | * [Indonesian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_id.md) 360 | 361 | # Siapa saya? 362 | 363 | Saya terinspirasi oleh [google-interview-university](https://github.com/jwasham/google-interview-university). Saya ingin membagikan pengalaman saya dan menunjukkan roadmap untuk menjadi pemrogram low-level karena saya menemukan bahwa keterampilan ini tidak seumum dulu. Selain itu, banyak pelajar dan pemula menanyakan kepada saya bagaimana mereka bisa menjadi pemrogram tingkat rendah dan engineer kernel Linux. 364 | 365 | FYI, saya memiliki pengalaman lebih dari 10 tahun sebagai seorang pemrogram low-level: 366 | * Pemrograman Assembly 80x86 367 | * Perangkat hardware dengan chip Atmel dan firmware 368 | * Pemrograman sistem Bahasa C untuk Unix 369 | * Driver perangkat di linux 370 | * Kernel Linux: page allocation 371 | * Kernel Linux: driver block device dan modul md -------------------------------------------------------------------------------- /README_it.md: -------------------------------------------------------------------------------- 1 | * [Università della programmazione a basso livello](#Low-Level-Programming-University) 2 | * [Che cos'è](#What-is-it) 3 | * [Che cos'è il basso livello](#What-Is-the-Low-Level) 4 | * [Teoria](#Theory) 5 | * [Linguaggi](#Languages) 6 | * [Assembly](#Assembly) 7 | * [Linguaggio C](#C-language) 8 | * [Applicazioni](#Applications) 9 | * [Hardware e Firmware](#Hardware-Firmware) 10 | * [Il kernel Linux e i driver di dispositivo](#Linux-kernel-and-device-driver) 11 | * [Leggi con attenzione](#Read-carefully) 12 | * [Riferimenti](#References) 13 | * [Futuro della programmazione a basso livello](#Future-of-low-level-programming) 14 | * [Traduzioni](#Translation) 15 | 16 | # Università della programmazione a basso livello 17 | 18 | ## Che cos'è? 19 | 20 | Questa pagina è per i principianti che vogliono essere programmatori a basso livello. 21 | 22 | L'inspirazione proviene dalla pagina [google-interview-university](https://github.com/jwasham/google-interview-university). Vorrei condividere la mia esperienza e mostrare un piano per diventare un programmatore a basso livello perchè mi sono reso conto che queste skill non sono così diffuse come una volta. Inoltre, molti studenti e principianti mi chiedono come possono diventare dei programmatori a basso livello e ingegneri del kernel di Linux. 23 | 24 | Questa pagina non potrà mai includere ogni link/libro/corso a riguardo. 25 | Ad esempio, questa pagina introduce Arduino ma non sono presenti informazioni dettagliate riguardo ad esso e alla programmazione embedded. Il resto spetta a te. Hai letto la parola chiave "Arduino" dalla quale puoi partire; perciò il tuo prossimo passo sarà probabilmente ricercarla su Google, comprare il kit e **sperimentare** per te stesso, non collezionare libri gratuiti e link. Ricorda che questa pagina è solo un piano. 26 | 27 | Per tua informazione, ho oltre 10 anni di esperienza come programmatore a basso livello: 28 | * Programmazione assembly 80x86 29 | * Driver per hardware con chip e firmware Atmel chip 30 | * Programmazione di sistema in linguaggio C per Unix 31 | * Driver di dispositivo per Linux 32 | * Kernel linux: allocazione di pagina 33 | * Kernel linux: dispostivi a blocchi e modulo md 34 | 35 | ## Che cos'è il basso livello? 36 | 37 | Identifico come programmazione a basso livello, quella programmazione che è molto vicina alla macchina, usando un linguaggio a basso come C o Assembly. Ciò è in contrasto la programmazione ad alto livello, tipica delle applicazioni denominate user-space, che utilizzano linguaggi ad alto livello (es. Python, Java). 38 | * [Wikipedia: Linguaggio di programmazione a basso livello](https://it.wikipedia.org/wiki/Linguaggio_di_programmazione_a_basso_livello) 39 | 40 | Sì la programmazione di sistemi è volto vicina al concetto della programmazione a basso livello. Questa pagina include il design di hardware e lo sviluppo di firmware che non è incluso nella programmazione di sistema. 41 | * [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming) 42 | 43 | Per l'ultimo, questa pagina include argomenti che spaziano dalle componenti hardware al kernel Linux. Ciò è un enorme collezioni di strati. Un documento di una singola pagina non potrà mai coprire i dettagli di tutti gli strati, perciò lo scopo di questo documento è di servire come punto iniziale per la programmazione a basso livello. 44 | 45 | ## Teoria 46 | 47 | Ci sono due teorie di fondo applicate alla programmazione di basso livello: 48 | * Architettura di computer 49 | * Sistemi operativi 50 | 51 | Penso che il miglior sistema per imparare la teoria è seguendo un corso. Leggere libri non è male ma prende molto tempo e fatica. Puoi trovare buoni corsi nelle universtà online, per esempio, Coursera.org e edx.org. La teoria è teoria. Non penso tu possa prendere un 10 con lode in classe, giusto capendo lì il quadro generale. Migliorerai in continuazione con l'esperienza. 52 | 53 | Ti introduco vari libri che ho letto. Sono libri di testo che sono utilizzati solitamente nelle università. Se non ci sono classi con quei libri, è consigliato spendere un po' di tempo su di essi. 54 | 55 | * Architettura di computer 56 | - Computer Architecture, Fifth Edition: A Quantitative Approach 57 | - Computer Systems: A Programmer's Perspective 58 | - Computer Organization and Design, Fourth Edition: The Hardware/Software Interface 59 | * Sistemi operativi 60 | - The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design 61 | - The Design of the UNIX Operating System 62 | - Operating Systems: Internals and Design Principles by William Stallings 63 | C'è una lista finita di buoni libri. Non voglio dire che dovresti leggere molti libri. Leggine giusto uno molto attentamente. Una volta che impari una teoria, implementa un codice di prova per esso. Implementare una cosa è meglio che conoscere centinaia di teorie. 64 | 65 | ## Linguaggi 66 | 67 | ### Assembly 68 | 69 | * [assembly 8086 con emu8086](https://github.com/gurugio/book_assembly_8086) 70 | * concetti base della CPU e dell'architettura dei computer 71 | * concetti base del linguaggio di programmazione C of C programming language 72 | * [programmazione assembly a 64bit (traduzione inglese in corso)](https://github.com/gurugio/book_assembly_64bit) 73 | * concetti base di una CPU moderna e dell'architettura di computer 74 | * concetti base di reverse engineering e di debug di codice C 75 | * _necessito aiuto per la traduzione_ 76 | * [Manuale di riferimento per l'architettura ARM](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 77 | * Completa guida dell'architettura ARM 78 | * Design ed organizzazione di un computer 79 | * [Edizione MIPS](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 80 | * [Edizione ARM](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 81 | * Libri accademici che spiegano come ogni componente di un computer lavora in dettaglio 82 | * Spiegano in dettaglio i vari concetti di un'architettura che costituisce un computer 83 | * Non sono orientati a diventare fluido in un linguaggio assembly specifico 84 | * L'edizione MIPs e ARM copre gli stessi argomenti ma analizzando una differente architettura 85 | * Entrambi le edizioni contengono esempi per il mondo x86 86 | 87 | ### Linguaggio C 88 | 89 | Non ci sono scorciatorie. Leggi l'intero libro e risolvi tutti gli esercizi. 90 | 91 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 92 | * [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) 93 | * [C moderno](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf) 94 | * Per il nuovo standard C 95 | * [La programmazione parallela è difficile, e, se lo è, cosa puoi farci?](https://www.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html) 96 | * implementazione cruda della sincronizzazione con C 97 | * Essenziale per la programmazione C a larga scala (specialmente per la programmazione di kernel) 98 | * [Sfida di programmazione C?](https://github.com/gurugio/lowlevelprogramming-university/blob/master/c-language-challenge_it.md) 99 | * Piano per un servizio come il "[The Eudyptula Challenge]"(http://eudyptula-challenge.org/) 100 | * Semplicemente un idea al momento.. 101 | * Se puoi creare tutti i progetti piccoli di quella pagina, potresti iniziare con grandi progetti 102 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 103 | * Guida all'ottimizzazione utilizzando C e un po' di assembly x86 104 | * Comincia dal 8088 fino ad oggi 105 | * Focus speciale sull'ottimizzazione della grafica a basso livello 106 | 107 | ## Applicazioni 108 | 109 | ### Hardware e firmware 110 | 111 | Se vuoi essere un ingegnere dei sistemi embedded, sarebbe meglio iniziare con un kit hardware semplice, come ad esempio partire con l'ultimo chipset ARM. 112 | 113 | * [Arduino Start Kit](https://www.arduino.cc/) 114 | * Ci sono varie serie ma il "Arduino Start Kit" ha il processore più semplice(Atmega328P) e un libro che ti guida 115 | * Atmega328P ha un core a 8bit che un buon punto di inizio per la "progettazione di circuiti" and lo "sviluppo firmware". 116 | * Non hai bisogno di sapere come disegnare schemi e strutture, e di assemblare i chip 117 | * Ma hai bisogno di sapere come leggere gli schemi e capire come i chip sono connessi 118 | * Sviluppatori firmware dovrebbero essere in grado di legge gli schemi e capire come inviare i dati ai dispositivi interessati. 119 | * Segui la guida! 120 | * [manuale 8086](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 121 | * Se sei un principiante sull'architettura x86, anche il 8086 è, una buona guida per l'architettura dei processori e l'assembly 80x86 122 | * [manuale 80386](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 123 | * Miglior guida per la modalità protetta e i meccanismi di paginazione del processore 80x86 124 | * Versione web: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 125 | 126 | A qeusto punto, dovrebbe essere una buona idea partire con l'ultimo processore x86 o ARM. 127 | * https://www.raspberrypi.org/ 128 | * https://beagleboard.org/ 129 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 130 | 131 | Per esempio, la scheda Raspeberry Pi ha un processore Cortex-A53 che supporta un set di istruzioni a 64-bit. 132 | Questo ti permette di far esperienza su un processore moderno con rPi. 133 | Sì puoi comparlo...ma...come hai intenzione di utilizzarlo? 134 | Se non ha un obiettivo di progetto, probabilmente lascerai la scheda in un cassetto e te ne dimenticherai come ogni altro gadget che hai comprato in precedenza. 135 | 136 | Perciò ti raccomando un progetto. 137 | * [Crea il tuo kernel](http://wiki.osdev.org/Getting_Started) 138 | * Spunti interessanti: https://www.reddit.com/r/osdev/ 139 | 140 | Ho creato [un kernel giocattolo](https://github.com/gurugio/caos) che supporta la modalità long 64-bit, paginazione e un cambio di contesto molto essenziale. Creare un kernel giocattolo è un buon sistema per capire l'architettura moderna e il controllo dell'hardware. 141 | 142 | Ovviamente, tu hai già l'ultimo processore e gli ultimi dispositivi hardware. 143 | Il tuo portatile! Il tuo desktop! Hai tutto ciò per poter iniziare. 144 | Non hai bisogno di compare nulla. 145 | L'emulatore qemu può, emulare gli ultimi porocessori ARM e Intel. 146 | Perciò ogni cosa necessiti e` già sottomano. 147 | Ci sono molti kernel giocattolo e documenti a cui puoi far riferimento. 148 | Installa qemu e crea il tuo piccolo kernel che semplicemente si avvia, avvia la paginazione e stampa alcuni messaggi. 149 | 150 | Altri kernel giocattolo: 151 | * https://littleosbook.github.io/ 152 | * https://tuhdo.github.io/os01/ 153 | 154 | ### Kernel linux kernel e driver di dispositivo 155 | 156 | Non hai bisogno di creare un sistema operativo completo. 157 | Unisciti alla comunità Linux e partecipa nello sviluppo. 158 | 159 | #### Leggi attentamente 160 | 161 | * Libri: leggi i seguenti in ordine 162 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 163 | * I concetti base di Unix sono applicati su tutti i sistemi operativi. 164 | * Questo libro è ottimo per i concetti sui sistemi operativi. 165 | * [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) 166 | * Fai una prova su tutti gli esempi 167 | * [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) 168 | * Capire la struttura del kernel Linux 169 | * [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) 170 | * Leggi questi libro e fai rifermento ai sorgenti kernel 2.6 in contemporanea 171 | * Mai iniziare con l'ultima versione, la 2.6 è più che sufficiente! 172 | * Usa qemu e gdb per eseguire i sorgenti del kernel linea per linea 173 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu 174 | * https://gurugio.kldp.net/wiki/wiki.php/howto_debug_kernel 175 | * Usa busybox per creare un file system molto semplice che impiega un secondo per avviarsi 176 | * https://gurugio.kldp.net/wiki/wiki.php/qemu_kernel 177 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 178 | * È come un insegnate privato bravissimo che ti guida su cosa fare. 179 | * Se non sai cosa fare, parti da qui. 180 | * [Block layer and device driver(translation in progress)](https://github.com/gurugio/book_linuxkernel_blockdrv) 181 | * inizia da un semplice dispositivo a blocchi di esempio (Ramdisk) con code multiple 182 | * prosegui fino al dispositivo di blocco 183 | * _necessità di aiuto per la traduzione_ 184 | * [md driver of Linux kernel(in progress)](https://github.com/gurugio/book_linuxkernel_md) 185 | * come funziona lo strumento mdam e come chiava il driver md 186 | * come funziona il driver md 187 | * _necessità di aiuto per la traduzione_ 188 | 189 | #### Riferimenti 190 | 191 | Controlla qui se necessiti di qualcosa 192 | 193 | * [Homepage di Free-electrons](http://free-electrons.com/docs/) 194 | * molte diapositive che introducono concetti interessanti, specialmente ARM-Linux 195 | * [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 196 | * guida per iniziare la programmazione kernel 197 | 198 | ## Futuro della programmazione a basso livello 199 | 200 | Non conosco il futuro, ma sto tenendo osservato RUST. 201 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 202 | 203 | Se avessi una settimana libera e sono da solo, vorrei imparare RUST. 204 | Questo perchè RUST è, il linguaggio più recente con il quale posso sviluppare un driver di dispositivo Linux. 205 | 206 | IoT è un trend nuovo, perciò vale controllare quali sistemi operativi sono per l'IoT. 207 | ARM, Samsung e alcune aziende hanno il loro sistema operativo realtime ma tristemente molti di essi sono a sorgenti chiusi. 208 | Ma la Fondazione Linux ha una soluzione: Zephyr 209 | * https://www.zephyrproject.org/ 210 | 211 | Il server cloud tipico ha così tanti strati, per esempio, il sistema operativo host, driver kvm, processo qemu, sistema operativo guet e applicazioni di servizio. Perciò i container sono sviluppati per fornire una virtualizzazione leggera. In un prossimo futuro, un nuovo concetto di OS, chiamato sistema operativo libreria o Unikernel, rimpiazzerà il tipico stack software per la virtualizzazione. 212 | * http://unikernel.org/ 213 | 214 | # Traduzioni 215 | Inviami una pull request se desideri che questa pagina venga tradotto. La elencherò qui. 216 | -------------------------------------------------------------------------------- /README_ru.md: -------------------------------------------------------------------------------- 1 | * [Университет Низкоуровневого Программирования](#Low-Level-Programming-University) 2 | * [Что это такое?](#What-is-it) 3 | * [Что значит "низкоуровневый"?](#What-Is-the-Low-Level) 4 | * [Теория](#Theory) 5 | * [Языки](#Languages) 6 | * [Ассемблер](#Assembly) 7 | * [Язык C](#C-language) 8 | * [Язык Rust](#Rust-language) 9 | * [Приложения](#Applications) 10 | * [Железо && Прошивки](#Hardware-Firmware) 11 | * [Ядро Linux и драйвера устройств](#Linux-kernel-and-device-driver) 12 | * [Следуй осторожно](#Follow-carefully) 13 | * [Ссылки](#References) 14 | * [Прочие приложения](#Other-applications) 15 | * [Будущее низкоуровневого программирования](#Future-of-low-level-programming) 16 | * [Как начать?](#How-to-start) 17 | * [Перевод](#Translation) 18 | * [Кто я такой?](#who-am-i) 19 | 20 | # Университет Низкоуровневого Программирования 21 | 22 | ## Что это такое? 23 | 24 | Вдохновляясь [google-interview-university](https://github.com/jwasham/coding-interview-university), мне бы хотелось поделиться опытом и показать путь к становлению программистом низкого уровня, потому что соответствующие навыки перестали быть столь обыденными, каковыми были раньше. К тому же, многие учащиеся и просто новички часто меня сами спрашивают, как стать низкоуровневым программистом и разработчиком ядра Linux в частности. 25 | 26 | Очевидно, что на одной странице нельзя указать каждую ссылку/книгу/курс. То есть, хоть эта страница и представляет читателю Arduino, на ней нет более детальной информации о ней и встраиваемых системах. Идти дальше необходимо самому. Имея ключевое слово "Arduino", можно воспользоваться поисковыми сервисами, купить кит и начать делать с ним что-нибудь самому, а не просто собирать ссылки и бесплатные книги. Прошу помнить, что вся эта страница является лишь путеводителем для новичков. 27 | 28 | Прим. [переводчика](https://github.com/LabunskyA): 29 | не для всех ссылок и книг существует русский аналог или перевод. Тех, что нашел, должно быть достаточно для начала пути, но, в любом случае, английский язык является необходимым навыком для успешного развития своих навыков в данной сфере. Поэтому к оригинальным совета добавлю от себя: **учи английский**. 30 | 31 | ## Что значит "низкоуровневый"? 32 | 33 | Я определяю низкоуровневое программирование как очень близкое к устройству, используя низкоуровневые языки программирования, такие как C или ассемблер, на контрасте с высокоуровневым программированием, типичного для приложений в user-space, использующим языки высокого уровня (такие как Python, Java). 34 | * [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language), [на русском](https://ru.wikipedia.org/wiki/Низкоуровневый_язык_программирования) 35 | 36 | Да, системное программирование является очень близким по смыслу концептом к низкоуровневому программированию. Но эта страница также включает проектирование аппаратных средств и разработку прошивок, которые не входят в понятие системного программирования. 37 | * [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming), [на русском](https://ru.wikipedia.org/wiki/Системное_программное_обеспечение) 38 | 39 | Наконец, эта страница включает темы от аппаратных компонентов до ядра Linux. Между ними невероятно большое число слоев. Документ на одну страницу никогда не сможет покрыть детали каждого из них, поэтому его целью является лишь дать точку входа в мир низкоуровневого программирования. 40 | 41 | ## Теория 42 | 43 | Низкоуровневое программирование базируется на двух теориях: 44 | * Архитектура Компьютеров 45 | * Операционные Системы 46 | 47 | Мне кажется, лучший способ выучить теорию - пройти соответствующий курс. Чтение книг само по себе не плохо, но отнимает слишком много времени и сил. При желании, можно найти много хороших курсов в онлайн университетах, в частности, на coursera.org и edx.org. 48 | Но теория - это лишь теория. Не думаю, что необходимо закончить курс на отлично, чтобы понять общую суть. 49 | Ты будешь становиться лучше и лучше с ростом опыта. 50 | 51 | Позволь мне представить несколько книг, которые я читал. Они широко используются в качестве учебников в университетах. Если их нет или не было у читателя в университете, то стоит потратить немного времени на ознакомление. 52 | * Архитектура Компьютеров 53 | * Computer Architecture, Fifth Edition: A Quantitative Approach 54 | * [Компьютерная Архитектура. Количественный подход. Издание 5-е](http://www.technosphera.ru/files/book_pdf/0/book_348_882.pdf) 55 | * Computer Systems: A Programmer's Perspective 56 | * [Компьютерные системы: архитектура и программирование](https://www.ozon.ru/context/detail/id/2355879/) 57 | * Computer Organization and Design, Fourth Edition: The Hardware/Software Interface 58 | * [Архитектура компьютера и проектирование компьютерных систем](https://www.labirint.ru/books/317754/) 59 | * Операционные системы 60 | * The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design 61 | * The Design of the UNIX Operating System 62 | * [Архитектура операционной системы Unix](http://lib.ru/BACH/) 63 | * Operating Systems: Internals and Design Principles by William Stallings 64 | * [Операционные системы](https://www.ozon.ru/context/detail/id/1150703/) 65 | * Рекомендуемые курсы 66 | * [CS401: Operating Systems](https://learn.saylor.org/mod/page/view.php?id=921) 67 | 68 | Список хороших книг бесконечен. Не хочу сказать, что нужно перемолоть множество книг: достаточно и одной, но прочитанной внимательно. Когда бы ты не учил теорию, попробуй свои силы в ее реализации. **Одна практическая реализация лучше, нежели знание сотни теорий** 69 | 70 | ## Языки 71 | 72 | ### Ассемблер 73 | 74 | Выбери один, х68 или ARM. Нужды знать оба нет смысла. Не имеет смысла даже знать сам язык по себе. Суть состоит в понимании внутренности процессора и компьютера в целом. То есть, нет нужды практиковаться в ассемблере самой последней модели. Выбери 8086 или Cortex-M. 75 | 76 | * [Программирование на ассемблере 8086 с помощью emu8086](https://github.com/gurugio/book_assembly_8086) 77 | * базовые концепты процессора и архитектуры компьютера 78 | * базовые концепты языка программирования C 79 | * [Программирование на 64-битном ассемблере (перевод на англ. в процессе)](https://github.com/gurugio/book_assembly_64bit) 80 | * базовые концепты современного процессора и архитектуры компьютера 81 | * базовые концепты дезассемблирования и отладки кода на C 82 | * _нужна помощь в переводе на английский_ 83 | * [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 84 | * Полная справка по программированию на ARM 85 | * [Паттерсон, Хеннесси: Архитектура компьютера и проектирование компьютерных систем](https://www.labirint.ru/books/317754/) 86 | * [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 87 | * [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 88 | * [RISC-V Edition](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 89 | * Академические книги, объясняющие работу каждого компонента компьютера с самых основ. 90 | * Объясняют в деталях разные концепты, составляющие архитектуру компьютера. 91 | * Они не нацелены на читателец, которые хотят стать специалистами в каждом отдельном языке ассемблера. 92 | * Издания для MIPS и ARM покрывают одни и те же темы, различающиеся архитектурами. 93 | * Оба издания содержат примеры из мира x86 94 | 95 | ### Язык C 96 | 97 | Тут коротких путей нет. Просто читай всю книгу и решай все упражнения. 98 | 99 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 100 | * [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) 101 | * [Брайан У. Керниган, Деннис М. Ритчи, Язык программирования C, 2-е издание](https://www.ozon.ru/context/detail/id/2480925/) 102 | * [Modern C](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf) 103 | * Для нового стандарта C 104 | * [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) 105 | * базовая реализация синхронизации в C 106 | * Необходим для крупномасштабного программирования на C (особенно, для программирования на уровне ядра) 107 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 108 | * Если ты закончил читать одну или две книги по C, то ты ДОЛЖЕН начать делать что-нибудь. 109 | * Выбери что угодно по нраву. 110 | * Сначала, сделай что-нибудь свое, после чего сравни с чужим исходным кодом. Очень важно проводить подобные сравнения. Улучшить свои навыки можно только при чтении чужого кода, обучаясь использованию лучших методов. Книги мертвы, код же живет. 111 | * [Проекты на C и других языках](https://github.com/danistefanovic/build-your-own-x) 112 | * Найди больше интересных проектов 113 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 114 | * Справочник по оптимизации с использованием C и капли ассемблера x86 115 | * Начиная с 8088 до сегодняшнего дня 116 | * Особый фокус на низкоуровневых оптимизациях графики 117 | * [Framework and plugin design in C (Korean)](https://github.com/gurugio/book_cprogramming) 118 | * Как разработать фреймворк и плагин на C для крупномасштабного ПО 119 | * Планируется перевод на английский 120 | 121 | Если хочешь стать экспертном в программировании на C, посети https://leetcode.com/. Удачи! 122 | 123 | ### Язык Rust 124 | 125 | Я уверен, что следующий язык для системного программирования будет Rust. 126 | Я предоставлю лист того что я делал чтобы выучить Rust. 127 | 128 | [Линус Торвальдс сказал - "Если резко обстоятельства не изменятся, то он [Rust] появится в 6.1."](https://www.zdnet.com/article/linus-torvalds-rust-will-go-into-linux-6-1/) 129 | 130 | * [The Rust Programming Language](https://doc.rust-lang.org/book/) 131 | * Хорошо для знакомства с языком, но имеет мало примеров и упражнений. 132 | * [Rust by Example](https://doc.rust-lang.org/rust-by-example/) 133 | * Пока читаешь "The Rust Programming Language", можешь находить примеры и упражнения здесь. 134 | * Но здесь не так много упражнений которые ты можешь сделать для себя. Только некоторые примеры включают в себя "сделай это" упражнения, и они очень простые. 135 | * [Programming Rust, 2nd](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/) 136 | * Глубокое ознакомление с языком, но также имеет мало примеров и упражнений. 137 | * [Exercism](https://exercism.org/tracks/rust) 138 | * Хорошие упражнения для практики индивидуальных особенностей Rust. 139 | * Я не уверен что Менторы активно работают, но этого будет достаточно чтобы сравнивать свои решения с другими. 140 | * После отправки своего решения, ты можешь видеть решения других во вкладке "Community solutions" (с поры Exercism V3). 141 | * Много легких упражнений нацелено на функциональные особенности, такие как map/filter/any и т.д. 142 | * [Легкий Rust](https://dhghomon.github.io/easy_rust/) 143 | * Книга написанная на несложном английском. 144 | * Ютуб материалы: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk 145 | * [Let's get rusty](https://www.youtube.com/c/LetsGetRusty) 146 | * Много ютуберов делают курсы по Rust, но этот понравился мне больше всего. 147 | * Он выставляет последний новости по Rust. Заслуживает подписки. 148 | * [Rust для Linux](https://github.com/Rust-for-Linux) 149 | * Смотри примеры источников как Rust попал в ядро Linux 150 | 151 | ## Приложения 152 | 153 | ### Железо && Прошивки 154 | 155 | Если хочешь стать системным инженером встраиваемых систем, то лучше начать с простых kit'ов для разработки, нежели с последнего чипсета ARM. 156 | 157 | * [Arduino Start Kit](https://www.arduino.cc/) 158 | * Существует множество серий Arduino, но "Arduino Start Kit" имеет наиболее простой процессор (Atmega328P) и книгу-гайд. 159 | * Atmega328P имеет 8-битное ядро, с которого хорошо начинать в сфере проектирования цифровых схем и разработки прошивок. 160 | * Тебе не требуется знать, как создавать схематики и макеты, а так же собирать чипы. 161 | * Но нужно знать, как читать схематики и понимать, как чипы соединены между собой. 162 | * Разработчик прошивок должен уметь читать схематики и понимать, как передать данные на целевое устройство. 163 | * Следуй гайду! 164 | * [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 165 | * Если ты не знаком с архитектурой x86, то 8086 также является хорошим гайдом архитектуры процессора и ассембрела 80x86 166 | * [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 167 | * Лучший гайд защищенног режима и механизма подкачки страниц процессора 80x86 168 | * Веб-версия: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 169 | 170 | К этому моменту, можно приступать к последним процессорам архитектур ARM и x86. 171 | * https://www.raspberrypi.org/ 172 | * https://beagleboard.org/ 173 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 174 | 175 | Для примера, плата Raspberry Pi имеет процессор Cortex-A53, поддерживающий 64-битный набор инструкций. 176 | Это позволяет получить опыт в работе с современной процессорной архитектуры с помощью rPi. 177 | Да, его можно купить... но... что ты собираешься с ним делать? 178 | Если нет целевого проекта, скорее всего ты просто положишь плату в дальний ящик и забудешь о ней как и обо всех других, купленных до этого. 179 | 180 | Поэтому, я рекомендую следующий проект. 181 | * [Создание своего собственного ядра](http://wiki.osdev.org/Getting_Started) 182 | * Хорошие ссылки: https://www.reddit.com/r/osdev/ 183 | * [Учимся разработке операционных систем используя Linux и Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 184 | * (Описание проекта) Этот репозиторий содержит пошаговый гайд, учащий создавать простое ядро операционной системы с нуля...(пропуск)...Каждый урок создан таким образом, что сначала объясняет, как некоторые фичи ядра реализованы в RPI OS, и лишь потом пытается продемонстрировать работу подобного функционала в ядре Linux. 185 | 186 | Я сделал [игрушечное ядро](https://github.com/gurugio/caos), поддерживающее 64-битный "длинный" режим, подкачку страниц и очень простое переключение контекста. создания ядра является хорошим способом понять архитектуру современного компьютера и управление "железом". 187 | 188 | Вообще говоря, у тебя уже есть доступ к последнему процессору и последним аппаратным устройствам. 189 | Твой ноутбук! Твой ПК! Ты уже имеешь все необходимое для старта! 190 | Не нужно ничего покупать. 191 | QEMU может эмулировать последние процессоры ARM и x86. 192 | То есть, все необходимое на руках. 193 | Существует множество игрушечных ядер и документации для справки. 194 | Просто установи QEMU эмулятор и создай микро-ядро, которое способно загрузиться, включить подкачку и вывести текстовые сообщения. 195 | 196 | Другие игрушечные ядра: 197 | * https://littleosbook.github.io/ 198 | * https://tuhdo.github.io/os01/ 199 | 200 | ### Ядро Linux и драйвера устройств 201 | 202 | Не нужно создавать свою полноценную операционную систему. 203 | Присоединйяся к сообществу Linux и участвуй в разработке. 204 | 205 | #### Следуй аккуратно 206 | 207 | * Книги (читать в следующем порядке): 208 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 209 | * [Морис Дж. Бах, Архитектура операционной системы Unix](http://lib.ru/BACH/) 210 | * Базовые концепты Unix применимы ко всем операционным системам. 211 | * Эта книга хороша для изучения ключевых концептов ОС. 212 | * [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) 213 | * [Дж. Корбет, Linux. Драйверы устройств](http://padabum.net/d.php?id=137122) 214 | * Сделай все примеры самостоятельно 215 | * [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) 216 | * [Роберт Лав, Разработка ядра Linux](https://www.ozon.ru/context/detail/id/2918313/) 217 | * Пойми устройство ядра Linux 218 | * [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) 219 | * [Д. Бовет, Ядро Linux](https://www.ozon.ru/context/detail/id/3589107/) 220 | * Читай эту книгу и исходный код ядра Linux v2.6 одновременно 221 | * Никогда не начинай с последней версии, v2.6 будет достаточно! 222 | * Используй qemu и gdb для отслеживания работы кода строчка за строчкой 223 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdЧТо за проводаb-and-qemu 224 | * https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md 225 | * Использый busybox для создания простейшей файловой системы, которая будет грузиться за одну секунду 226 | * https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md 227 | * Остальные ресурсы, которые я рекомендую: 228 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 229 | * Гид по практике и отличные упражнения по созданию драйверов устройств для Linux с необходимыми API. 230 | * Думаю, этот документ представляет читателю практически все необходимые API ядра. 231 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 232 | * _К сожалению, это соревнование больше не принимает новых участников._ Мейнтейнер сказал, что планирует переход на новый формат. Надеюсь на его возвращение в скором времени. 233 | * Но ты можешь найти вопросы по этому соревнованию с помощью Гугла. Некоторые люди уже выложили результат своей работы. Найди вопросы и попытайся решить их самостоятельно, после чего сравни свое решение с чужими. 234 | * Это как иметь потрясающего частного учителя, который направляет тебя и говорит, что нужно делать. 235 | * Если ты не знаешь, чем заняться, просто начни с этого. 236 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 237 | * Этот проект еще не завершен. 238 | * Я всегда думал, что сделать ядро, похожее на Linux, является лучшим способом понять его самого. 239 | * [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv) 240 | * начни с драйвера простого блочного устройства (Ramdisk) с много-очередным режимом 241 | * иди дальше на уровень блоков 242 | * перевод на английский завершен, просьба прислать отзыв по нему. 243 | * [md driver of Linux kernel(Korean)](https://github.com/gurugio/book_linuxkernel_md) 244 | * как утилиты mdadm работают и как вызывает md driver 245 | * как работает сам md driver 246 | 247 | #### Ссылки 248 | 249 | Посмотри здесь, если понадобится что-то еще 250 | 251 | * [Free-electrons homepage](http://free-electrons.com/docs/) 252 | * множество презентаций, представляющих хорошие темы, особенно Linux на ARM 253 | * [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 254 | * гид для входа в программирование уровня ядра 255 | 256 | ### Прочие приложения 257 | 258 | Да, ты можешь быть и не заинтересован в линуксе и прошивках. Если так, то можно найти и другие сферы: 259 | * Системное программирование и драйвера устройств под Windows 260 | * Безопасность 261 | * Реверс инженеринг 262 | 263 | У меня нет каких-либо знаний в данных сферах. Поэтому прошу отправить мне любую информацию о них для новичков. 264 | 265 | **Ядра и драйверы - еще не все низкоуровневое программирование.** Одним из наиболее важных приложений низкоуровневого программирования являются распределенные файловые системы и хранилища. Подробное их описание находится на пределами фокуса этого документа, но существует отлличный курс, в котором можно попробовать себя в данной сфере. 266 | * Курс: https://pdos.csail.mit.edu/archive/6.824-2012/ 267 | * Исходный код для работы с ним: https://github.com/srned/yfs 268 | 269 | ## Будущее низкоуровневого программирования 270 | 271 | Мне неизвестно будущее, но я посматриваю на RUST. 272 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 273 | 274 | Если бы у меня была свободная неделя в одиночестве, я бы его выучил. 275 | Просто потому, что RUST - самый новый язык программирования, на котором возможна разработка драйверов устройств под Linux. 276 | * https://github.com/tsgates/rust.ko 277 | 278 | IoT теперь уже является трендом, поэтому стоит посмотреть на ОС для него. 279 | ARM, Samsung и некоторые другие компании имеют свои собственные ОС реального времени, но, к сожалению, многие из них имеют закрытый исходный код. 280 | Но Linux Foundation также имеет свое решение: Zephyr 281 | * https://www.zephyrproject.org/ 282 | 283 | Обычные облачные сервера имеют множество слоев; в частности, хостовую ОС, драйвер kvm, процесс qemu, гостевая ОС и сервисное приложение. Контейнер был создан, чтобы предоставить легку. виртуализацию. В ближайшем будущем, новый концепт ОС, так называемый "библиотечная ОС" или Unikernel, может заменить типичный стэк SW для виртуализации. 284 | * http://unikernel.org/ 285 | 286 | Big data и облачные вычисления требуют хранения все больших и больших объемов данных. Некоторые диски, напрямую подключенные к серверам, не могут удовлетворить требующуюся емкость, стабильность и производительность. Поэтому были проведены исследования для создания больших систем хранения данных с помощью множества машин, соединенных высокоскоростной сетью. Поначалу они были сфокусированы на создании одного большого тома-хранилища. Но теперь предлагаю множества томов, выделенных для множества виртуальных машин. 287 | * https://en.wikipedia.org/wiki/Software-defined_storage 288 | * https://en.wikipedia.org/wiki/Clustered_file_system 289 | * https://en.wikipedia.org/wiki/Ceph_(software) 290 | 291 | ## Как начать? 292 | 293 | Однажды, я получил письмо с таким вопросом. На этой странице представлено множество информационных книг, курсов и проектов. И в том, что я забыл напистаь тут ответ на него - моя вина. Конечно, не существует единственного прямого пути. Я просто пишу, что делал сам и в каком порядке. Если ты уже знаком с чем-то, то можешь это пропустить. ПОВТОРЯЮ, это все лишь пример, которому ты можешь следовать. Если не знаешь, что делать, просто делай все ПО ПОРЯДКУ. 294 | 295 | * Чтение книг с теорией ОС: как минимум "The Design of the UNIX Operating System" 296 | * Учеба ассемблера и C 297 | * [Программирование на ассемблере 8086 с помощью emu8086](https://github.com/gurugio/book_assembly_8086) 298 | * Этого достаточно для понимания базовых концептов программирования на ассемблере. Не нужно делать что-то на практике. 299 | * [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) 300 | * [Язык программирования C, 2-е издание](https://www.ozon.ru/context/detail/id/2480925/) 301 | * НЕ ЗАБУДЬ решить каждое управжнение! 302 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 303 | * Сделай что-нибудь на C 304 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/): Найди один или два интересных проектов и сделай свой собственный. 305 | * [leetcode.com](https://leetcode.com/): Если не можешь найти интересный проект, будет так же полезно сфокусироваться на структурах данных и алгоритмах. 306 | * Сделай проект с железом 307 | * Raspberry Pi или Arduino - это не принципиально. Тебе нужен опыт контроля железа непосредственно с помощью C. ТОЛЬКО C! 308 | * Запрыгни в ядро Linux 309 | * Начни с драйверов 310 | * Прочти [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) 311 | * Или на русском: [Дж. Корбет, Linux. Драйверы устройств](http://padabum.net/d.php?id=137122) 312 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 313 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 314 | * Прочти [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. 315 | * Или на русском: [Роберт Лав, Разработка ядра Linux](https://www.ozon.ru/context/detail/id/2918313/) 316 | * Если ты хочешь стать разработчиком ядра Linux 317 | * то должен прочитать [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) 318 | * После этого попробуй создать игручешное ядро 319 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 320 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 321 | * Прочитай исходный код ядра и документацию на https://lwn.net/ 322 | * Или найди другую тему. 323 | 324 | # Перевод 325 | 326 | Присылайте мне pull-реквесты, если хотите перевести эту страницу. Я перечислю их здесь. 327 | 328 | * [Английский (оригинал)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README.md) 329 | * [Китайский](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md) 330 | * [Португальский (Бразильский)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md) 331 | * [Итальянский](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md) 332 | * [Чешский](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md) 333 | * [Русский (эта страница)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md) 334 | 335 | # Кто я такой? 336 | 337 | Вдохновляясь [google-interview-university](https://github.com/jwasham/coding-interview-university), мне бы хотелось поделиться опытом и показать путь к становлению программистом низкого уровня, потому что соответствующие навыки перестали быть столь обыденными, каковыми были раньше. К тому же, многие учащиеся и просто новички часто меня сами спрашивают, как стать низкоуровневым программистом и разработчиком ядра Linux в частности. 338 | 339 | Для информации, у меня более 10 лет опыта в качестве низкоуровневого программиста, мой опыт включает: 340 | * Программирование на ассмемблере под 80x86 341 | * Аппаратные средства на чипах Atmel и прошивки для них 342 | * Язык C и системное программирование под Unix 343 | * Драйвера устройств под Linux 344 | * Ядро Linux: подкачка страниц 345 | * Ядро Linux: драйвер блочного устройства и md module 346 | -------------------------------------------------------------------------------- /README_tr.md: -------------------------------------------------------------------------------- 1 | UYARI1: Lütfen bu sayfanın içeriğini blogunuza kopyalamayın. Bu sayfayı paylaşabilirsiniz ama lütfen orijinal link ile paylaşın. İyi belge ve açık kaynak projesinin yazarlarını bu şekilde övüyoruz. 2 | 3 | UYARI2: Lütfen düşük seviyeli programlamanın popüler olmadığını ve şu anda düşük seviyeli kod yazan programcıları işe alan çok fazla şirket olmadığını unutmayın. İş bulmam gittikçe zorlaşıyor. 4 | Henüz profesyonel bir kariyere başlamadıysanız, diğer alanları da dikkatlice değerlendirmenizi tavsiye ederim. 5 | 6 | UYARI3: Eğer hızlı bir başlangıç istiyorsanız, "Nasıl Başlanır?" bölümüne gidin. 7 | 8 | * [Düşük Seviyeli Programlama Üniversitesi](#Düşük-Seviyeli-Programlama-Üniversitesi) 9 | * [Nedir?](#Nedir) 10 | * [Düşük Seviye nedir?](#Düşük-Seviye-nedir) 11 | * [Teori](#Teori) 12 | * [Diller](#Diller) 13 | * [Assembly](#Assembly) 14 | * [C dili](#C-dili) 15 | * [Rust dili](#rust-dili) 16 | * [Çalışma Alanları](#Çalışma-Alanları) 17 | * [Donanım && Firmware](#Donanım-Firmware) 18 | * [Linux çekirdeği and aygıt sürücüleri](#Linux-çekirdeği-ve-aygıt-sürücüleri) 19 | * [Referanslar](#Referanslar) 20 | * [Diğer Çalışma Alanları](#Diğer-Çalışma-Alanları) 21 | * [Düşük Seviyeli Programlamanın Geleceği](#Düşük-Seviyeli-Programlamanın-Geleceği) 22 | * [Nasıl Başlanır?](#Nasıl-Başlanır) 23 | * [Çeviriler](#Çeviriler) 24 | * [Ben Kimim?](#Ben-Kimim) 25 | 26 | # Düşük Seviyeli Programlama Üniversitesi 27 | 28 | ## Nedir? 29 | 30 | Bu yazıyı [google-interview-university](https://github.com/jwasham/coding-interview-university)'den esinlendim. Deneyimlerimi paylaşmak ve düşük seviyeli kod yazan bir programcı olma yolunda bir yol haritası göstermek istiyorum çünkü bu becerilerin eskisi kadar yaygın olmadığını anladım. Ek olarak, birçok öğrenci ve yeni başlayanlar bana nasıl düşük seviyeli kod yazan programcı ve Linux çekirdek kodu yazan bir mühendis olabileceklerini soruyor. 31 | 32 | Bu sayfa her bağlantıyı/kitabı/kursu içeremez. Örneğin bu sayfada Arduino tanıtılmaktadır ancak Arduino ve gömülü sistemler hakkında detaylı bilgi bulunmamaktadır. Kendin daha fazlasını araştırmalısın. Başlayabileceğiniz "Arduino" anahtar kelimesine sahipsiniz. Yani bir sonraki adımınız muhtemelen Arduino'yu araştırmak, bir Arduino geliştirme seti(kit) satın almak ve kendiniz için bir şeyler yapmaktır, bağlantı veya kitap toplamak değil. Lütfen bu sayfanın yeni başlayanlar için bir yol haritası olduğunu unutmayın. 33 | 34 | Düşük seviyeli programlama, bilgisayar biliminin bir parçasıdır. 35 | Öncelikle bilgisayar bilimi için eğitim almak kesinlikle çok daha iyi olacaktır. 36 | * [Bilgisayar Bilimleri alanında ücretsiz bir eğitime giden yol!](https://github.com/ossu/computer-science) 37 | 38 | 39 | ## Düşük Seviye nedir? 40 | 41 | Düşük seviyeli programlamayı, C veya Assembly gibi daha düşük seviyeli bir programlama dili kullanarak makineye çok yakın olan programlama olarak sınıflandırıyorum. Bu, yüksek seviyeli diller (örn. Python, Java) kullanan tipik kullanıcı alanı(userspace ve kernelspace kavramlarına bakınız) uygulamaları olan üst düzey programlamanın tersidir. 42 | * [Wikipedia: Low-level programming language](https://en.wikipedia.org/wiki/Low-level_programming_language) 43 | 44 | Evet, sistem programlama, düşük seviyeli programlamaya çok yakın bir kavramdır. Bu sayfa, sistem programlamasına dahil olmayan donanım tasarımını ve ürün yazılımı geliştirmeyi içerir. 45 | * [Wikipedia: System programming](https://en.wikipedia.org/wiki/System_programming) 46 | 47 | Son olarak, bu sayfa donanım bileşenlerinden Linux çekirdeğine kadar değişen konuları içerir. Bu, çok çeşitli katmanlardır. Tek sayfalık bir belge hiçbir zaman tüm katmanların ayrıntılarını kapsamaz, bu nedenle bu belgenin amacı, düşük seviyeli programlama için bir başlangıç ​​noktası olarak hizmet etmektir. 48 | 49 | ## Teori 50 | 51 | Düşük seviyeli programlamanın iki temel teorisi vardır: 52 | * Bilgisayar Mimarisi 53 | * İşletim Sistemleri 54 | 55 | Bence teori öğrenmenin en iyi yolu bir kurs almaktır. Kitap okumak fena değil ama çok zaman ve çaba gerektiriyor. Coursera.org ve edx.org gibi çevrimiçi üniversitelerde birçok iyi kurslar bulabilirsiniz. Teorik bilgi ile gerçeği yani pratik kodlama becerisini ayırt etmek gerekir. Sınıfta A+ almanız gerektiğini düşünmüyorum, sadece büyük resmi görün. Tecrübe ile gün geçtikçe daha iyi olacaksınız. 56 | 57 | Okuduğum birkaç kitabı tanıtmama izin verin. Genellikle üniversitelerde ders kitabı olarak kullanılırlar. Üniversitenizde bu kitapların olduğu bir sınıf yoksa, onları okumak için biraz zaman ayırmaya değer. 58 | 59 | * Bilgisayar Mimarisi 60 | * Computer Architecture, Fifth Edition: A Quantitative Approach 61 | * Computer Systems: A Programmer's Perspective 62 | * Computer Organization and Design, Fourth Edition: The Hardware/Software Interface 63 | * İşletim sistemleri 64 | * The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design 65 | * The Design of the UNIX Operating System 66 | * Operating Systems: Internals and Design Principles by William Stallings 67 | * Önerilen Kurslar 68 | * [CS401: Operating Systems from saylor.org](https://learn.saylor.org/course/view.php?id=94) 69 | * Genel Programlama Bilgisi 70 | * [Structure and Interpretation of Computer Programs](https://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Computer_Programs) 71 | * Bu nasıl iyi bir Yazılım Geliştirici olacağınızla alakalı. Sadece teoriğe değil tekniğe de ihtiyacınız var çünkü programlama bir tür el işidir. 72 | * Eğer Lisp/Scheme öğrenirseniz, diğer programlama dillerini daha kolay öğrenebilirsiniz. 73 | * [Egzersizlerin yaklaşık %80'ini çözdüm. Çözdüğüm her bir egzersize değdi.](https://github.com/gurugio/sicp_exercise) 74 | * Donanım Tasarımı 75 | * Kendi 8086 Mikroişlemci kitinizi geliştirin. 76 | * Eğer kendi donanım kartınızı geliştirmeyecekseniz, fiziksel bellek eşlemeli cihaz(physical memory mapped device)'ın ne olduğunu anlamayacaksınız. 77 | * Günümüzde işlemcilerin(AP - Application Processors) artık çok fazla akıllı özellikleri(Intellectual Properties) var. Bu yüzden bir işlemcinin çekirdeği ve çevre cihazların(peripheral devices) nasıl bağlı olduklarını bilemeyeceksiniz. 78 | * Kendi 8086 kitinizi geliştirirken, her bir çevre cihazı fiziksel hafızaya yerleştirme imkanınız var. Ve ana donanım cihazlarının(BUS, IRQ, Clock, Power vb.) nasıl çalışacağını kendi gözlerinizle ayarlayabilirsiniz. 79 | * Kendi 8086 kitimi üniversitede geliştirmiştim. Aldığım en değerli derslerden biriydi, kendi donanım kitini yap. Eğer donanım eski ve basit olursa daha iyi çünkü ayarlamalar için daha fazla uğraşırsınız. 80 | * İnternette "8086 kit" diye aratın. Donanım şemasını, parçalarını ve kılavuzlarını belli başlı internet sitelerinden alabilirsiniz. 81 | 82 | Sayısız iyi kitap listesi var. Çok kitap okumalısın demek istemiyorum. Sadece bir kitabı dikkatlice okuyun. Ne zaman bir teori öğrenirseniz, onun kodunu uygulayın. 83 | **Bir şeyi uygulamak, yüz teori bilmekten daha iyidir.** 84 | 85 | ## Diller 86 | 87 | ### Assembly 88 | 89 | X86 veya ARM arasından birini seçin. İkisini de bilmenize gerek yok. Assembly dilini bilmek önemli değil. Önemli olan bir CPU ve bilgisayarın içini(işleyiş) anlamaktır. Böylece en yeni CPU'nun assembly dilini yazmanıza gerek kalmaz. 8086 veya Cortex-M'yi seçin. 90 | 91 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 92 | * CPU ve bilgisayar mimarisinin temel kavramları 93 | * C programlama dilinin temel kavramları 94 | * [64bit assembly programming(translation in progress)](https://github.com/gurugio/book_assembly_64bit) 95 | * modern CPU ve bilgisayar mimarisinin temel kavramları 96 | * C kodunun disassemble edilmesi ve hata ayıklaması ile ilgili temel kavramlar 97 | * _need help for translation_ 98 | * [Learning assembly for linux-x64](https://github.com/0xAX/asm) 99 | * NASM ile saf 64-bit Assembly programlama ve GCC ile inline Assembly 100 | * [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 101 | * ARM programlamada eksiksiz referans 102 | * Bilgisayar Organizasyonu ve Tasarımı 103 | * [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 104 | * [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 105 | * [RISC-V Edition](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 106 | * Bir bilgisayarın her bileşeninin sıfırdan nasıl çalıştığını açıklayan akademik kitaplar. 107 | * Bilgisayar mimarisini oluşturan farklı kavramları ayrıntılı olarak açıklar. 108 | * Belirli bir Assembly dilinde uzmanlaşmak isteyen okuyucuları hedef almazlar. 109 | * MIPS ve ARM sürümü aynı konuları kapsar, ancak farklı bir mimariyi inceler. 110 | * Her iki sürüm de x86 dünyasındaki örnekleri içerir 111 | 112 | ### C dili 113 | 114 | Kestirme ve hızlı bir yol bulunmuyor. Sadece kitabın tamamını okuyun ve tüm alıştırmaları çözün. 115 | 116 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 117 | * [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) 118 | * [Modern C](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf) 119 | * Yeni C standardı için 120 | * [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) 121 | * C dili ile raw uyarlanması ve senkronizasyonu 122 | * Büyük ölçekli C programlama için gerekli (özellikle çekirdek programlama için) 123 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 124 | * Bir veya iki C programlama kitabını okumayı bitirirseniz, bir şeyler yapmanız GEREKİR. 125 | * Ne istersen onu seç. 126 | * Önce kendi başınıza yapın ve ardından başka birinin kaynak koduyla karşılaştırın. Kaynağınızı ve diğerlerini karşılaştırmak çok önemlidir. Becerinizi ancak diğerinin kaynağını okuduğunuzda ve daha iyi yöntemler öğrendiğinizde geliştirebilirsiniz. Kitaplar ölüdür ve kaynak kodlar yaşayan kaynaklardır. 127 | * [C and other languages based projects](https://github.com/danistefanovic/build-your-own-x) 128 | * daha ilginç projeler bulun 129 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 130 | * C ve biraz da x86 Assembly ile optimizasyon hakkında referans 131 | * 8088'den bugüne kadar 132 | * Düşük Seviyeli grafik optimizasyonuna özel odaklanın 133 | * [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming) 134 | * Büyük ölçekli yazılımlar için C'de çerçeve ve eklenti nasıl geliştirilir 135 | * Linux çekirdek kaynak okuma için çok temel programlama ipuçları 136 | 137 | C programlama uzmanı olmak istiyorsanız, https://leetcode.com/ sitesini ziyaret edin. İyi Şanslar! 138 | 139 | 140 | ### Rust dili 141 | 142 | Sistem programlama için bir sonraki dilin Rust olacağına eminim. 143 | Rust öğrenirken yaptıklarımı bir liste haline getireceğim. 144 | 145 | [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/) 146 | 147 | * [The Rust Programming Language](https://doc.rust-lang.org/book/) 148 | * Güzel bir giriş, ancak eksik örnek ve alıştırmalar. 149 | * [Rust by Example](https://doc.rust-lang.org/rust-by-example/) 150 | * "The Rust Programming Language"'i okurken, buradan örnek ve alıştırmalar bulabilirsiniz. 151 | * Ama kendinizin yapabileceği yeteri kadar alıştırma yok. Sadece bazı örneklerde "kendin-yap" alıştırmaları var ve onlarda çok basit. 152 | * [Programming Rust, 2nd](https://www.oreilly.com/library/view/programming-rust-2nd/9781492052586/) 153 | * Daha derin bir giriş, ama hala örnek ve alıştırmalardan yoksun. 154 | * [Exercism](https://exercism.org/tracks/rust) 155 | * RUST'ın kendine has özelliklerini öğrenmek için güzel alıştırmalar. 156 | * Mentörlerin aktif olarak çalışıp çalışmadığını bilmiyorum ama çözümüzü diğerleriyle karşılaştırmak için yeterli. 157 | * Çözümünüzü gönderdikten sonra, başkalarının çözümlerini "Community solutions" sekmesinde görebilirsizin (Exercism V3'den sonra geçerli). 158 | * Map/filter/any ve vb. fonksiyonel özellikler için çok sayıda giriş seviyesinde alıştırma. 159 | * [Easy rust](https://dhghomon.github.io/easy_rust/) 160 | * Basit bir İngilizce ile yazılmış bir kitap. 161 | * Youtube kaynakları: https://www.youtube.com/playlist?list=PLfllocyHVgsRwLkTAhG0E-2QxCf-ozBkk 162 | * [Let's get rusty](https://www.youtube.com/c/LetsGetRusty) 163 | * Youtube'da çok fazla Rust eğitimi yayınlayan var ama ben en çok bu eğitimi sevdim. 164 | * Rust hakkında son gelişmeleri yayınlıyor. Abone olmaya değer. 165 | * [Rust for Linux](https://github.com/Rust-for-Linux) 166 | * Örnek kaynakları inceleyin ve Rust'ın Linux Çekirdeğine nasıl girdiğini görün. 167 | 168 | 169 | ## Çalışma Alanları 170 | 171 | ### Donanım && Firmware 172 | 173 | Gömülü sistem mühendisi olmak istiyorsanız, en son ARM yonga setiyle başlamak yerine basit bir donanım geliştirme setinden(kitinden) başlamak en iyisi olacaktır. 174 | 175 | * [Arduino Başlangıç Kiti](https://www.arduino.cc/) 176 | * Birçok Arduino serisi vardır, ancak "Arduino Başlangıç ​​Kiti" en basit işlemciye (Atmega328P) ve kılavuz kitabına sahiptir. 177 | * Atmega328P, dijital devre tasarımına ve aygıt yazılımı geliştirmeye başlamak için iyi bir yer olan 8 bitlik bir çekirdeğe sahiptir. 178 | * Şemaları ve düzenleri nasıl çizeceğinizi ve çipleri nasıl monte edeceğinizi bilmenize gerek yok. 179 | * Ancak şemaları nasıl okuyacağınızı bilmeniz ve çiplerin nasıl bağlandığını anlamanız gerekir. 180 | * Firmware geliştiricileri, şemaları okuyabilmeli ve verileri hedef cihaza nasıl göndereceklerini bulabilmelidir. 181 | * Kılavuzu takip edin! 182 | * [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 183 | * X86 mimarisine yeni başlayan biriyseniz, 8086 işlemci mimarisi ve 80x86 derlemesi için de çok iyi bir kılavuzdur. 184 | * [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 185 | * 80x86 işlemcinin korumalı modu ve sayfalama mekanizması için en iyi kılavuz 186 | * Web sürümü: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 187 | 188 | Bu noktada, en son ARM veya x86 işlemciye başlamanız gerekir. 189 | * https://www.raspberrypi.org/ 190 | * https://beagleboard.org/ 191 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 192 | 193 | Örneğin, Raspberry Pi kartında 64-bit komut setini destekleyen bir Cortex-A53 İşlemci bulunur. 194 | Bu, RPi ile modern bir işlemci mimarisi deneyimlemenizi sağlar. 195 | Evet, satın alabilirsin ... ama ... onunla ne yapacaksın? 196 | Hedef projeniz yoksa, RPi kartı'nı bir çekmeceye atmanız ve daha önce satın almış olabileceğiniz diğer araçlar gibi unutmanız muhtemeldir. 197 | 198 | Bu yüzden size aşağıdaki projeleri öneriyorum. 199 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 200 | * İyi referanslar: https://www.reddit.com/r/osdev/ 201 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 202 | * (projenin açıklaması) Bu depo, basit bir işletim sistemi (OS) çekirdeğinin sıfırdan nasıl oluşturulacağını öğreten adım adım bir kılavuz içerir ... (atla) ... Her ders öyle tasarlandı ki önce bazı çekirdek özelliğinin RPi işletim sisteminde nasıl uygulandığını açıklar ve ardından aynı işlevselliğin Linux çekirdeğinde nasıl çalıştığını göstermeye çalışır. 203 | 204 | 205 | 206 | 64 bit long modu, sayfalamayı ve çok basit bağlam değiştirmeyi(context switching) destekleyen [basit bir kernel](https://github.com/gurugio/caos) yazdım. Basit bir çekirdek(kernel) yapmak, modern bilgisayar mimarisini ve donanım kontrolünü anlamak için güzel bir yoludur. 207 | 208 | Aslında, en son işlemciye ve en son donanım cihazlarına zaten sahipsiniz. 209 | Dizüstü bilgisayarın! Masaüstü bilgisayarınız! Başlamak için ihtiyacınız olan her şeye zaten sahipsin! 210 | Hiçbir şey almanıza gerek yok. 211 | QEMU emülatörü, en yeni ARM işlemcileri ve Intel işlemcileri sanal ortamında çalıştırabilir. 212 | Yani ihtiyacınız olan her şey elinizin altında. 213 | Başvurabileceğiniz birçok basit çekirdekler ve kılavuzlar var. 214 | Sadece QEMU'yu kurun ve sadece ayağa kalkan(boot), sayfalamayı(paging) açan ve bazı mesajları yazdıran küçük bir çekirdek yapın. 215 | 216 | Diğer basit çekirdekler(kernel): 217 | * https://littleosbook.github.io/ 218 | * https://tuhdo.github.io/os01/ 219 | 220 | ### Linux çekirdeği and aygıt sürücüleri 221 | 222 | Tam bir işletim sistemi oluşturmanıza gerek yok. 223 | Linux topluluğuna katılın ve geliştirmeye ortak olun. 224 | 225 | * Linux Çekirdeği ve Aygıt Sürücüleri(driver) ile ilgili başlangıç ​​seviyesinden ileri seviyeye bazı kaynaklar. 226 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 227 | * UNIX'in temel kavramları tüm işletim sistemlerine uygulanır. 228 | * Bu kitap, işletim sistemlerinin temel kavramlarını öğrenmek için çok iyi bir yerdir. 229 | * [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) 230 | * Kendiniz için tüm örnekleri yapın 231 | * [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) 232 | * Linux Kernel'in tasarımını anlayın 233 | * [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) 234 | * Bu kitabı ve v2.6 çekirdek kaynağını aynı anda okuyun 235 | * Asla en son sürümle başlamayın, v2.6 yeterlidir! 236 | * Çekirdek kaynağını satır satır çalıştırmak için qemu ve gdb'yi kullanın 237 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu 238 | * https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md 239 | * Önyüklemesi yalnızca bir saniye süren en basit dosya sistemini yapmak için busybox kullanın 240 | * https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md 241 | * Diğer kaynaklar: Önerdiğim kaynaklar 242 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 243 | * Linux aygıt sürücülerini temel çekirdek API'leri ile yapan pratik kılavuz ve mükemmel alıştırmalar 244 | * Bu belgenin neredeyse tüm temel çekirdek API'lerini tanıttığını düşünüyorum. 245 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 246 | * Ne yazık ki, bu meydan okuma yeni meydan okuyanları kabul etmiyor çünkü artık zorluk yok._ Bakımcı yeni bir format planladığını söyledi. Umarım en kısa zamanda geri gelir. 247 | * Ancak sorunun sorularını Google ile bulabilirsiniz. Bazı insanlar yaptıklarını zaten yükledi. Soruları bulun ve kendi başınıza çözmeye çalışın ve çözümünüzü diğerleriyle karşılaştırın. 248 | * Bu, size ne yapmanız gerektiği konusunda rehberlik eden harika bir özel öğretmen gibidir. 249 | * Ne yapacağınızı bilmiyorsanız, hemen başlayın. 250 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 251 | * Bu proje henüz tamamlanmadı. 252 | * Her zaman Linux çekirdeğine benzer bir çekirdek yapmanın Linux çekirdeğini anlamanın en iyi yolu olduğunu düşünüyorum. 253 | * [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv) 254 | * multi-queue mode ile basit bir blok sürücüsü örneğinden (Ramdisk) başlayın 255 | * blok katmanına bakın 256 | * İngilizceye çeviriyi tamamladım. Lütfen bana geri bildiriminizi gönderin. 257 | * [md driver of Linux kernel(Korean)](https://github.com/gurugio/book_linuxkernel_md) 258 | * mdadm aracı nasıl çalışır ve md sürücüsünü nasıl çağırır 259 | * md sürücüsü nasıl çalışır 260 | 261 | #### Referanslar 262 | 263 | Bir şeye ihtiyacınız olduğunda kontrol edeceğiniz kaynaklardan: 264 | 265 | * [Free-electrons homepage](http://free-electrons.com/docs/) 266 | * iyi konuları, özellikle ARM-linux'u tanıtan birçok slayt dosyasıdır. 267 | * [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 268 | * çekirdek programlamaya başlama kılavuzudur. 269 | 270 | ### Diğer Çalışma Alanları 271 | 272 | Evet, Linux veya firmware geliştirmeyle ilgilenmeyebilirsiniz. Öyleyse, başka çalışma alanları bulabilirsiniz: 273 | * Windows sistem programlama & aygıt sürücüleri(driver) 274 | * Bilgi Güvenliği(Security) 275 | * Tersine Mühendislik 276 | 277 | Bu çalışma alanları hakkında hiçbir bilgim yok. Lütfen yeni başlayanlar için yararlı olabilecek bu dosyanın formatına uygun içerikleri gönderin. 278 | 279 | **Çekirdekler ve sürücüleri, düşük seviyeli programlamanın tamamı değildir.** Düşük seviyeli programlamanın bir diğer önemli çalışma alanı, yazılım tanımlı depolama veya dağıtık dosya sistemidir. Bunların ayrıntılı açıklamaları bu belgenin kapsamı dışındadır ancak basit bir dağıtık dosya sistemini deneyebileceğiniz mükemmel bir kurs vardır. 280 | * Ders: https://pdos.csail.mit.edu/archive/6.824-2012/ 281 | * Referans'ın kaynağı: https://github.com/srned/yfs 282 | 283 | ## Düşük Seviyeli Programlamanın Geleceği 284 | 285 | Geleceği öngöremiyorum ama RUST programlama diline dikkatimi vermeye başladım. 286 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 287 | 288 | Kendime bir hafta zaman ayırabilseydim, RUST öğrenirdim. 289 | Bunun nedeni, RUST'ın Linux aygıt sürücülerini geliştirebileceğim en son dil olmasıdır. 290 | * https://github.com/tsgates/rust.ko 291 | 292 | IoT tercih edilmeye başlanan popüler ve yeni bir akım, bu nedenle IoT teknolojisiyle hangi işletim sistemlerinin uyumlu olduğunu kontrol etmeye değer görüyorum. 293 | ARM, Samsung ve bazı şirketlerin kendi gerçek zamanlı işletim sistemleri var, ancak ne yazık ki çoğu kapalı kaynak(yani kaynak kodu verilmeyen, kaynak kodunu düzenlemeye ve yeniden dağıtmaya izin vermeyen çalışmalar). 294 | Ancak Linux Vakfı'nın da bir çözümü var: Zephyr 295 | * https://www.zephyrproject.org/ 296 | 297 | Geleneksel bulut sunucularının birçok katmanı vardır; örneğin, ana işletim sistemi, kvm sürücüsü, qemu işlemi, konuk işletim sistemi ve hizmet uygulaması. Hafif sanallaştırma sağlamak için bir konteyner geliştirilmiştir. Yakın gelecekte, kütüphane işletim sistemi veya Unikernel olarak adlandırılan yeni bir işletim sistemi kavramı, sanallaştırma için tipik yazılım yığını yerine geçecektir. 298 | * http://unikernel.org/ 299 | 300 | Büyük veri ve bulut bilişim, daha büyük ve daha büyük depolama gerektirir. Doğrudan sunucu makinelerine takılan bazı diskler gerekli kapasite, kararlılık ve performansı karşılayamaz. Bu nedenle, yüksek hızlı bir ağ ile birbirine bağlanan birçok depolama makinesiyle büyük depolama sistemleri yapmak için araştırmalar yapılmıştır. Eskiden büyük bir depolama hacmi yapmaya odaklanırdı. Ancak şu anda birçok sanal makine için ayrılmış birçok birim sağlıyorlar. 301 | * https://en.wikipedia.org/wiki/Software-defined_storage 302 | * https://en.wikipedia.org/wiki/Clustered_file_system 303 | * https://en.wikipedia.org/wiki/Ceph_(software) 304 | 305 | ## Nasıl Başlanır? 306 | 307 | Nasıl başlayacağımı soran bir e-posta aldım. Bu sayfada kitaplar, kurslar ve projeler hakkında birçok bilgi var. Nasıl başlayacağımı yazmayı unutmak benim hatam. Maalesef [Kralın Şehrine](https://gameofthrones.fandom.com/wiki/King%27s_Landing) giden Kral Yolu bulunmuyor. Sadece sırayla ne yaptığımı yazacağım. Zaten bir şey yaptıysanız, lütfen atlayın. Ve YİNE belirtmeliyim ki, bu sadece nasıl başlayacağınızı veya ne yapacağınızı bilmiyorsanız, sırayla yapabileceğiniz bir örnek metindir. 308 | 309 | * İşletim sistemi teorisi kitapları okumak: en azından "The Design of the UNIX Operating System by Maurice J. Bach" okumalısınız. 310 | * Assembly ve C programlama dillerini öğrenmelisiniz. 311 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 312 | * Assembly programlama dilini okuyup anlayabiliyorsanız yeterlidir. Pratik bir şey yapmanıza gerek yoktur. 313 | * [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) 314 | * Her alıştırmayı çözmek için elinizden gelenin en iyisini yapın! 315 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 316 | * C ile pratik bir şeyler yapın 317 | * [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. 318 | * [leetcode.com](https://leetcode.com/): İlginç bir proje bulamazsanız, veri yapısı ve algoritmaya odaklanmak da iyi olacaktır. 319 | * Bir donanım projesi yapın 320 | * Raspberrypi veya Arduino arasında bir tercih yapmanız önemli değildir. Bir donanımı doğrudan yalnızca C ile kontrol etmek için bir deneyime ihtiyacınız var YALNIZCA C ile! 321 | * Bir ATmega128 geliştirme seti(kiti) satın almanızı ve LED'leri açmak/kapatmak, anahtar girişini algılamak ve metin LCD'sinde mesaj görüntülemek için bir aygıt yazılımı yapmanızı öneririm. Motor kontrol programı da çok iyi bir projedir: örneğin, çizgi izleyici. 322 | * Herhangi bir yazılım kütüphanesi KULLANMAYIN. Program indiricisi dışında her şeyi kendi başınıza yapmalısınız. 323 | * Linux Çekirdeğinin Temelleri 324 | * Düşük seviyeli programlama, işletim sistemine çok yakındır. İşletim sisteminin işleyişini bilmelisiniz. 325 | * Donanım aygıt sürücüleriyle başlayınız 326 | * [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) 327 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 328 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) belgelerini okuyunuz. 329 | * Linux Çekirdeğinin işleyişini anlamak için [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) kitabını okuyunuz. 330 | * Profesyonelleşmek için 331 | * Profesyonel Linux Çekirdek Geliştiricisi olmak istiyorsanız 332 | * [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) okumalısınız. 333 | * Sonra kendinize basit bir çekirdek yazın. 334 | * [Learn operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 335 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 336 | * Özgeçmişinizde kendi çekirdeğinizin github linkini koyun (Commit mesajlarına detaylı bilgi yazmayı unutmayın.) 337 | * https://lwn.net/ sitesindeki son sorunları(issue) inceleyin ve çözüme katılın. 338 | * "Güncel çekirdek yamaları"'nı "https://lwn.net/Kernel/" veya direkt "https://lwn.net/Kernel/Patches" üzerinden kontrol edin. 339 | * Kendinize ilginç bir yama bulun. Kaynak kodu anlamaya çalışın. Tabii ki bunu yapmak zor olacak ama deneyin. Her denediğinizde adım adım yaklaşacaksınız. 340 | * Çekirdek geliştirin ve kendi sisteminizde test edin. TLP(https://linux-test-project.github.io/) ile örneğin performans testi, stabilite testi yapın veya statik kod analizi yapın. 341 | * Eğer herhangi bir problem bulursanız: derleme uyarıları/hataları, performans düşüsü, kernel panic/oops veya herhangi bir problemi bildirin. 342 | * Eğer sorunsuz çalışırsa, bunu sistem özelliklerinizle beraber raporlayın. Yama sahibi "Reviewed-by" etiketi ile sizin adınızı yazar. 343 | * Kendi adınızı çekirdeğin git belgelerinde(log) bulun. 344 | * Veya başka alanlar bulun 345 | * Düşük seviye mühendislerin çalışabileceği çok fazla alan var: güvenlik, derleyici(compiler), donanım yazılımı(firmware), robotlar/arabalar diye gidiyor... 346 | 347 | 348 | # Çeviriler 349 | 350 | Bu sayfayı çevirmek istiyorsanız lütfen düzenleme talebi(pull request) gönderin. Burada listeleyeceğim. 351 | * [Chinese (Traditional)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tw.md) 352 | * [Chinese (Simplified)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md) 353 | * [Portuguese (Brazilian)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md) 354 | * [Italian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md) 355 | * [Czech](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md) 356 | * [Russian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md) 357 | * [Turkish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tr.md) 358 | * [Persian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fa.md) 359 | * [Spanish](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_es.md) 360 | * [French](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_fr.md) 361 | 362 | # Ben Kimim? 363 | 364 | Bu yazıyı [google-interview-university](https://github.com/jwasham/coding-interview-university)'den esinlendim. Deneyimlerimi paylaşmak ve düşük seviyeli kod yazan bir programcı olma yolunda bir yol haritası göstermek istiyorum çünkü bu becerilerin eskisi kadar yaygın olmadığını anladım. Ek olarak, birçok öğrenci ve yeni başlayanlar bana nasıl düşük seviyeli kod yazan programcılar ve Linux çekirdek kodu yazan bir mühendis olabileceklerini soruyor. 365 | 366 | Bilmenizi isterim ki düşük seviyeli kod yazan bir programcı olarak 10 yıldan fazla kod yazma deneyimine sahibim: 367 | * 80x86 platformunda Assembly programlama 368 | * ATmel çipli ve firmware'lı donanım cihazı 369 | * UNIX için C ile sistemi programlama çalışması 370 | * Linux'ta aygıt sürücüsü 371 | * Linux çekirdeği: sayfa ayırma(page allocation) 372 | * Linux çekirdeği: blok aygıt sürücüsü ve md modulü 373 | -------------------------------------------------------------------------------- /README_tw.md: -------------------------------------------------------------------------------- 1 | RNOTICE: 2 | Please notice that low-level programming is out of trend and currently 3 | there are not many companies hiring low-level developer. 4 | It is getting harder for me to find a job. 5 | If you does not start professional career yet, 6 | I would like to recommend you consider other fields carefully. 7 | 8 | __提醒__： 9 | 請注意，底層程式開發已不是主要趨勢，現今有許多公司已不再聘請底層程式開發者， 10 | 作者本身也越來越難找到相關的工作。 11 | 如果你並非全職專業技能者，我會建議你仔細考慮其他領域。 12 | 13 | * [底層程式開發的世界](#Low-Level-Programming-University) 14 | * [這篇文章在講什麼?](#What-is-it) 15 | * [什麼是底層](#What-Is-the-Low-Level) 16 | * [理論](#Theory) 17 | * [程式語言](#Languages) 18 | * [組合語言](#Assembly) 19 | * [C 語言](#C-language) 20 | * [應用程式](#Applications) 21 | * [硬體 && 韌體](#Hardware-Firmware) 22 | * [Linux 核心與設備驅動程式](#Linux-kernel-and-device-driver) 23 | * [參考](#References) 24 | * [其他的應用領域](#Other-applications) 25 | * [關於底層程式開發的前景](#Future-of-low-level-programming) 26 | * [如何開始?](#How-to-start) 27 | * [翻譯版本](#Translation) 28 | * [我是誰?](#who-am-i) 29 | 30 | # 底層程式開發的世界 31 | 32 | ## 這篇文章在講什麼? 33 | 34 | 我是被一篇文章所啟發 [google-interview-university](https://github.com/jwasham/coding-interview-university)。 35 | 我想要來分享我自己的經驗並且展示如何成為一個底層程式開發者， 36 | 因為我發現這些技能並不像以前一樣那麼的常見。 37 | 此外，也有越來越多的學生及初學者開始問我， 38 | 如何成為一個底層開發者及 Linux 核心工程師。 39 | 40 | 這篇文章並不會包含所有相關的 連結/書籍/課程。 41 | 例如，這篇文章包含了 Arduino，但並不會有關於 Arduino 及嵌入式系統的細節資訊， 42 | 你得到了 Arduino 這個關鍵字，接下來所要做的就是走出自己的一條路。 43 | 這條路可能是從 googling Arduino 開始，買一些器材、設備，為你的學習做出實際的行動， 44 | 而非收集一堆資訊卻不去閱讀。 45 | 請記得，這只是一個給初學者的學習指南而已。 46 | 47 | 底層程式開發是電腦科學的一部分。 48 | 當然，如果能先學習有關電腦科學的相關教育知識會是更好的。 49 | 50 | * [免費的自學電腦科學途徑!](https://github.com/ossu/computer-science) 51 | 52 | 53 | ## 什麼是底層? 54 | 55 | 什麼是底層？什麼是高階層？ 56 | 我區分的方式是，你是否使用了 C 或組合語言去撰寫了與機器相關的程式。 57 | 這相對於其他高階層的程式開發有很大的區別， 58 | 因為高階層的程式語言開發，通常不需要注意機器、硬體， 59 | 使用者空間 (user-space) 的應用程式，通常會使用高階層程式語言 (例如： Python, Java) 60 | 61 | * [維基百科: 底層程式語言](https://en.wikipedia.org/wiki/Low-level_programming_language) 62 | 63 | 64 | 你可能猜到了一些，系統程式開發是一種非常靠近底層程式開發的型態。 65 | 但是系統程式開發通常不會包含硬體設計及韌體開發，而這篇文章會包含這些額外的內容 66 | 67 | * [維基百科: 系統程式開發](https://en.wikipedia.org/wiki/System_programming) 68 | 69 | 70 | 最後，這篇文章會從硬體的元件，講到 Linux 核心。 71 | 這跨越了非常多的領域，一篇文章不太可能包含所有的細節， 72 | 所以請把這篇文章當成一個進入底層程式開發的起始點。 73 | 74 | 75 | ## 理論 76 | 77 | 底層程式開發有兩種主要的背景知識 78 | 79 | * 電腦組織架構 80 | * 作業系統 81 | 82 | 83 | 我認為學習理論最好的方式是跟著一個課程學習， 84 | 自己讀書並不是不好，只是會耗費你大量的時間與努力， 85 | 你應該可以在網路上找到各個大學的線上課程，例如像 Coursera.org 和 edx.org。 86 | 理論就是理論，我不認為你一定要在課堂上拿到 A+，只需要在腦中有一個粗略的背景知識。 87 | 你會隨著經驗增加而越來越厲害。 88 | 89 | 90 | 讓我介紹幾本我讀過的書。 91 | 這些書通常是大學中的教科書。 92 | 就算你的大學中沒有任何的課程是使用這些書，它們還是很值得你花時間去閱讀 93 | 94 | * 電腦組織與架構 95 | * Computer Architecture, Fifth Edition: A Quantitative Approach 96 | * Computer Systems: A Programmer's Perspective 97 | * Computer Organization and Design, Fourth Edition: The Hardware/Software Interface 98 | * 作業系統 99 | * The Magic Garden Explained: The Internals of UNIX System V Release 4 an Open Systems Design 100 | * The Design of the UNIX Operating System 101 | * Operating Systems: Internals and Design Principles by William Stallings 102 | * 建議的課程 103 | * [CS401: 作業系統 from saylor.org](https://learn.saylor.org/course/view.php?id=94) 104 | 105 | 106 | 世界上有無窮無盡的好書等著你。 107 | 我不想說你應該每一本都去念，只要選個一、兩本，仔細的去讀、去學， 108 | 不論你學到了什麼理論，把程式碼實做出來 109 | **實做無價，把東西做出來，知識才真的屬於你** 110 | 111 | ## 程式語言 112 | 113 | ### 組合語言 114 | 115 | 選擇 X86 或 ARM 其中一種。不需要兩種都知道。 116 | 至於選那一種也不是很重要，因為學習組合語言的重點是，你必須要知道 CPU 與電腦的運作方式， 117 | 所以不需要練習最新 CPU 的組合語言，嘗試選一種 8086 或 Corex-M 118 | 119 | 120 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 121 | * CPU 與電腦架構的基本知識 122 | * C 語言開發的基本知識 123 | * [64bit assembly programming(translation in progress)](https://github.com/gurugio/book_assembly_64bit) 124 | * 現代 CPU 與電腦架構的基本知識 125 | * C 語言之反組譯、偵錯的基本知識 126 | * _need help for translation（原作者需要有人幫忙翻譯這本書）_ 127 | * [Learning assembly for linux-x64](https://github.com/0xAX/asm) 128 | * 使用 GCC 之 64-bit 基本語法組合語言與 NASM 之程式開發 129 | * [ARM Architecture Reference Manual, 2nd Edition](http://www.mypearsonstore.ca/bookstore/arm-architecture-reference-manual-9780201737196) 130 | * ARM 程式開發之完整參考 131 | * 電腦組織與設計 132 | * [MIPS Edition](https://www.amazon.ca/Computer-Organization-Design-MIPS-Interface/dp/0124077269/) 133 | * [ARM Edition](https://www.amazon.ca/Computer-Organization-Design-ARM-Interface/dp/0128017333/) 134 | * [RISC-V Edition](https://www.amazon.com/Computer-Organization-Design-RISC-V-Architecture/dp/0128122757) 135 | * 學校的書會解釋電腦的每一個元件是如何運作的 136 | * 解釋有關於電腦組織架構的相關細節與之間的差別 137 | * 這些書籍也沒有期望它們的讀者會想要成為組合語言的專家 138 | * MIPS 與 ARM 的部份會包含同樣的主題在不同的架構上 139 | * 同樣的版本都會有 x86 的例子 140 | 141 | ### C 語言 142 | 143 | 關於 C 語言，沒有捷徑。 144 | 必須閱讀全部的書籍並且實做所有的練習。 145 | 146 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 147 | * [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) 148 | * [Modern C](http://icube-icps.unistra.fr/img_auth.php/d/db/ModernC.pdf) 149 | * 關於 C 語言的新標準 150 | * [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) 151 | * 用 C 語言實做同步化 152 | * 用 C 語言實做大型程式的必須知識 (通常是與核心程式開發相關)) 153 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/) 154 | * 如果你讀完了一、兩本 C 語言的書，那你應該要實做一些東西 155 | * 選一個你喜歡的 156 | * 嘗試先實做你自己的程式，接著再去對照別人的程式碼，如此就可以學習到哪裡寫的好，哪裡寫的不好，閱讀其他人的程式碼，永遠都可以學到一些東西 157 | * [C and other languages based projects](https://github.com/danistefanovic/build-your-own-x) 158 | * 找一些有趣的專案做做看 159 | * [Michael Abrash’s Graphics Programming Black Book, Special Edition](http://www.jagregory.com/abrash-black-book/) 160 | * 增進 C 語言與 x86 組合語言效能的參考 161 | * 今天，從 8088 開始 162 | * 專注底層圖形之效能增進 163 | * [Framework and plugin design in C](https://github.com/gurugio/book_cprogramming) 164 | * 如何用 C 語言在大型軟體中開發框架與套件 165 | * 如何閱讀 Linux 核心程式碼之基本程式開發的提示 166 | 167 | 如果你想成為 C 語言的專家, 請到 168 | 169 | https://leetcode.com/. 170 | 171 | Good luck! 172 | 173 | ## 應用程式 174 | 175 | ### 硬體 && 韌體 176 | 177 | 如果你想成為一個嵌入式系統的工程師， 178 | 比起學習最新的 ARM 晶片，最好還是從一個簡單的硬體套件開始， 179 | 180 | * [Arduino Start Kit](https://www.arduino.cc/) 181 | * 市面上有很多種 Arduinos 系列， 但 "Arduino Start Kit"有最簡單的處理器 (Atmega328P) 和說明書。 182 | * Atmega328P 有一個 8-bit 核心，是一個很好做數位電路設計和韌體開發的起點 183 | * 你不需要知道如何去畫電路圖、不需要知道如何布局、更不需要知道如何封裝晶片。 184 | * 但你需要知道如何去讀電路圖，也必須知道晶片應該如何連接。 185 | * 韌體開發者需要知道如何閱讀電路圖及設備之間如何傳遞訊息。 186 | * 跟著指南書走! 187 | * [8086 manual](https://edge.edx.org/c4x/BITSPilani/EEE231/asset/8086_family_Users_Manual_1_.pdf) 188 | * 如果你是 x86 架構的初學者，8086 也是非常好的學習領域，關於處理器架構和 80x86 組合語言。 189 | * [80386 manual](http://css.csail.mit.edu/6.858/2015/readings/i386.pdf) 190 | * 80x86 處理器的保護模式及 paging 機制。 191 | * 網頁版本: https://pdos.csail.mit.edu/6.828/2011/readings/i386/toc.htm 192 | 193 | 194 | 在這個部份，你必須要有一定程度的技術能力來開始接下來的部份，最新的 ARM 或 x86 處理器 195 | 196 | * https://www.raspberrypi.org/ 197 | * https://beagleboard.org/ 198 | * https://www.arduino.cc/en/ArduinoCertified/IntelEdison 199 | 200 | 舉例，樹莓派的開發板上有 Cortex-A53 的處理器，該處理器支援 64 bit 的指令集 201 | 202 | 新的樹莓派可以讓你體驗先進的處理器架構，你可以買新的沒錯， 203 | 但如果你沒有任何的想法，不知道買來要幹麻，你很可能很快就會把板子忘在抽屜裡面了， 204 | 就像你之前買的那些設備一樣，對吧，你懂的。 205 | 206 | 所以，我有個好建議。 207 | 208 | * [寫一個你自己的核心](http://wiki.osdev.org/Getting_Started) 209 | * 很棒的參考: https://www.reddit.com/r/osdev/ 210 | * [用樹莓派來學習如何做 Linux 作業系統與核心開發](https://github.com/s-matyukevich/raspberry-pi-os) 211 | * （嘗試描述這個專案）(description of the project) 這個程式庫有說明書，教你如何一步一步的從無到有，建立一個簡單的作業系統核心，每一個課程都是專門為了初學者設計過的，告訴你每一個核心的功能，如何實做在樹莓派作業系統中，並嘗試以此示範在 Linux 核心中同樣的功能是如何運作的 212 | 213 | 我做了一個 [小型核心程式](https://github.com/gurugio/caos) 214 | 它支援 64-bit 長指令模式，paging，簡單的 context switching， 215 | 用 __小型核心程式__ 來示範，讓人可以比較簡單的了解現代的電腦架構與硬體控制 216 | 217 | 事實上，你早就有最新的處理器及硬體設備，就是你的筆記型電腦，你隨時可以開始。 218 | 你可以不用再買其他東西，qemu 模擬器可以模擬最新的 ARM 處理器跟 Intel 處理器 219 | 220 | 你需要的，你都有， 221 | 你可以參考很多東西，隨便找都有一堆小型核心程式跟文件， 222 | 安裝 qemu 模擬器，編譯出一個小核心， 223 | 啟動核心之後，啟動 paging，印幾行訊息出來看看。 224 | 225 | 226 | 還有一些你可以參考的小型核心程式 : 227 | 228 | * https://littleosbook.github.io/ 229 | * https://tuhdo.github.io/os01/ 230 | 231 | ### Linux 核心與設備驅動程式 232 | 233 | 要做一整個完整的作業系統是非常困難的，其實你不需要自己做， 234 | 加入 Linux 社群，參與開發就好 235 | 236 | 初階到進階之 Linux 核心與設備驅動程式開發的相關資源 237 | 238 | * 書籍: 照著順序讀以下的書 239 | * [The Design of the Unix Operating System](https://www.amazon.com/Design-UNIX-Operating-System/dp/0132017997) 240 | * Unix 作業系統被應用到其他所有作業系統的基本觀念 241 | * 這本書是可以學到作業系統的重要觀念 242 | * [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) 243 | * 自己嘗試實做出所有的練習 244 | * [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) 245 | * 了解 Linux 核心設計 246 | * [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) 247 | * 請讀這本書，並同時閱讀 Linux 核心原始碼 v2.6 248 | * 不需要讀最新的 Linux 核心，v2.6 就已經足夠! 249 | * 使用 qemu 及 gdb 去一行一行的把核心程式碼跑起來 250 | * http://stackoverflow.com/questions/11408041/how-to-debug-the-linux-kernel-with-gdb-and-qemu 251 | * https://github.com/gurugio/linuxdeveloptip/blob/master/qemu-gdb-kdump.md 252 | * 用 busybox 去做一個最簡單的檔案系統，只需要一秒就可以啟動的檔案系統 253 | * https://github.com/gurugio/linuxdeveloptip/blob/master/minikernelwithbusybox.md 254 | * 其他資源: 我推薦的，不用錢的資源 255 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 256 | * Linux 設備驅動程式與常備核心 APIs 之實做指南與經典範例 257 | * 我認為這份文件介紹了幾乎全部的必要之核心 APIs 258 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 259 | * _可惜，這個挑戰已經不再接受新的挑戰者申請了，因為已經不再有挑戰的關卡_ 這個服務的維護者說過，他/她已經在準備一個新的服務，我希望可以趕快看到 260 | * 雖然原本的服務已經不在了，但是有些人上傳了之前的相關題目，可以用 google 找找看，並且嘗試自己解題，再看看你做的與別人做的差別在那 261 | * 這就像是家教老師，告訴你應該怎麼做 262 | * 如果你不知道要做什麼，那改作這個 263 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 264 | * 這個專案還沒完成 265 | * 我一直認為做一個跟 Linux 核心很像的核心，就是學習 Linux 核心最好的方式 266 | * [Block layer and device driver](https://github.com/gurugio/book_linuxkernel_blockdrv) 267 | * 用多重佇列模式，來開始學做簡單的區塊設備驅動程式 (Ramdisk) 268 | * 進入到區塊層 269 | * 原作者已經將原文翻譯成英文，看過後，有想法可以回饋給原作者 270 | * [md driver of Linux kernel(Korean)](https://github.com/gurugio/book_linuxkernel_md) 271 | * mdadm 工作如何運作及如何調用 md 驅動程式 272 | * md 驅動程式如何運作 273 | 274 | #### 參考 275 | 276 | 如果你遇到一些困難，試著找看看有沒有你需要的資料 277 | 278 | * [Free-electrons homepage](http://free-electrons.com/docs/) 279 | * 有很多的投影片，介紹很多主題，特別是關於 ARM-linux 280 | * [Julia Evans's posting: You can be a kernel hacker!](http://jvns.ca/blog/2014/09/18/you-can-be-a-kernel-hacker/) 281 | * 如何開始核心程式開發指南 282 | 283 | ### 其他的應用程式 284 | 285 | 或許你對於 Linux 跟韌體並不真的那麼有興趣。 286 | 那你還可以考慮試試其他的應用領域： 287 | 288 | * Windows 系統程式開發 & 設備驅動程式 289 | * 資訊安全 290 | * 逆向工程 291 | 292 | 原作者本身並沒有關於這些領域的相關知識， 293 | 如果有人懂這方面的知識，原作者期待可以收到相關的入門資料。 294 | 295 | 296 | **核心以及驅動程式並不是底層程式開發的全部** 297 | 有一個很重要的底層應用程式，稱為『軟體定義儲存裝置』或『分散式檔案系統』。 298 | 關於此領域的知識細節已經超出了這個文件所要介紹的範圍， 299 | 但如果你有興趣，可以參考這個課程，可以了解簡單的分散式檔案系統。 300 | 301 | * 課程: https://pdos.csail.mit.edu/archive/6.824-2012/ 302 | * 參考來源: https://github.com/srned/yfs 303 | 304 | ## 底層程式開發的未來 305 | 306 | 其實我並不知道未來會是怎樣，但是我持續在注意 RUST 這個程式語言。 307 | 308 | * https://hacks.mozilla.org/2016/11/rust-and-the-future-of-systems-programming/ 309 | 310 | 如果我有一些獨處的時間，我會試著學 RUST。 311 | 因為 RUST 是嶄新的程式語言，也可以拿來開發 Linux 設備驅動程式。 312 | 313 | * https://github.com/tsgates/rust.ko 314 | 315 | 物連網是目前的新趨勢，所以很值得去了解物連網與其相關的作業系統。 316 | ARM、三星，還有一些其他的公司有發展它們自己的即時作業系統， 317 | 可惜的是大部分都為閉源程式（相對於開源程式）。 318 | 但別氣餒，Linux 基金會也有自己的開源解決方案：Zephyr 319 | 320 | * https://www.zephyrproject.org/ 321 | 322 | 一個典型的雲端伺服器會有好幾層的技術堆疊， 323 | 例如：會有主層作業系統、客層作業系統、KVM 驅動程式、qemu 的行程、應用程式服務。 324 | 325 | 有一種應用程式稱為容器，容器已經可以提供輕量型的虛擬化。 326 | 在不久的將來，會有新的作業系統概念，也就是所謂的 library OS 或稱 Unikernel， 327 | 有可能會取代目前典型的軟體虛擬化技術。 328 | 329 | * http://unikernel.org/ 330 | 331 | 大數據及雲端計算需要非常非常多的儲存空間。 332 | 有時候，在伺服器內的硬碟容量、穩定性及效能，已經不能負荷其服務所需。 333 | 因此目前有人在研究，嘗試開發出一個巨型儲存系統，這個系統是用許多分散式的儲存設備，配合高速網路互相連接，所搭建起來的。 334 | 上述的技術主要是用來搭建一個巨大的儲存空間。 335 | 而目前這樣的技術主要是用來做虛擬機器的使用空間。 336 | 337 | * https://en.wikipedia.org/wiki/Software-defined_storage 338 | * https://en.wikipedia.org/wiki/Clustered_file_system 339 | * https://en.wikipedia.org/wiki/Ceph_(software) 340 | 341 | ## 如何開始? 342 | 343 | 我收到了許多的信件來問我說，你說的東西很棒，但是該怎麼開始？ 344 | 其實你們所需要的東西都已經在這篇文章裡面了，不管是書籍、課程、還是專案。 345 | 我想我忘了告訴大家該怎麼開始做這一切， 346 | 但其實關於這個問題…，就如同詢問，該如何從河岸的一岸到另外一岸？ 347 | 該如何到達彼岸，並沒有正確的答案 348 | 349 | [King's Landing](https://gameofthrones.fandom.com/wiki/King%27s_Landing) 350 | 351 | 我所能做的就是把我曾經做過得寫出來。 352 | 如果你也曾經學過這些，就跳過去學下一個， 353 | 我必須再次聲明，這只是個讓你參考如何開始的範例。 354 | 355 | * 閱讀作業系統理論書籍: 最少要看一下 "The Design of the UNIX Operating System by Maurice J. Bach" 356 | * 學組合語言與 C 語言 357 | * [8086 assembly programming with emu8086](https://github.com/gurugio/book_assembly_8086) 358 | * 如果你已經了解組合語言的概念，這樣就夠了。 359 | * [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) 360 | * 試著自己去解出書中所有的題目 361 | * [C Programming: A Modern Approach, 2nd Edition](https://www.amazon.com/C-Programming-Modern-Approach-2nd/dp/0393979504) 362 | * C 語言專案的實做 363 | * [C Project Based Tutorials?](https://www.reddit.com/r/C_Programming/comments/872rlt/c_project_based_tutorials/): 找一兩個有興趣的專案做做看，然後試著做你自己的專案。 364 | * [leetcode.com](https://leetcode.com/): 如果你真的找不到有興趣的專案，那就到 leetcode 練習練習你的資料結構跟演算法，這樣也是 OK 的。 365 | * 做一些硬體相關的專案 366 | * 用樹莓派或者是 Arduino 都可以，你需要的是用 C 語言控制硬體的經驗，記住，只有 C 語言! 367 | * 我建議買一個 Atmega128 套件，然後編譯一個韌體去試著開關 LEDs, 在文字 LCD 上觀察觀察輸入與顯示的狀況。用程式來控制馬達也是一個很好的專案，例如: 尋軌機器人。 368 | * 試著不要去用任何程式庫，你應該試著自己做出輪子，這樣才能學到從無到有的知識。 369 | * Linux 核心的基礎 370 | * 底層程式開發是非常靠近作業系統的，你應該知道作業系統裡面是怎運作的。 371 | * 如何起手設備驅動程式 372 | * 請閱讀 [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) 373 | * [Linux device driver labs](https://linux-kernel-labs.github.io/) 374 | * [The Eudyptula Challenge](http://eudyptula-challenge.org/) 375 | * 請閱讀 [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 核心的運作。 376 | * 成為專業人士、擁有專業的知識 377 | * 如果你想成為專業的 Linux 核心開發者 378 | * 一定要讀 [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) 379 | * 試著自己做出並編譯一個具體而微的核心 380 | * [Learning operating system development using Linux kernel and Raspberry Pi](https://github.com/s-matyukevich/raspberry-pi-os) 381 | * [Making your own kernel](http://wiki.osdev.org/Getting_Started) 382 | * 注意最新的內容消息 https://lwn.net/ 並加入這個社群. 383 | * 試著找其他你有興趣的議題 384 | 385 | # 翻譯版本 386 | 387 | 如果你翻譯了這份文章，請發個 pull request 給我， 388 | 我會將你翻譯的部份放在下方的列表中 389 | 390 | * [Chinese (Simpllified)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cn.md) 391 | * [Chinese (Traditional))](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_tw.md) 392 | * [Portuguese (Brazilian)](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_pt.md) 393 | * [Italian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_it.md) 394 | * [Czech](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_cz.md) 395 | * [Russian](https://github.com/gurugio/lowlevelprogramming-university/blob/master/README_ru.md) 396 | * [Turkish](https://github.com/masscollaborationlabs/lowlevelprogramming-university/blob/master/README_tr.md) 397 | 398 | # 原作者? 399 | 400 | 401 | 我因為閱讀了 [google-interview-university](https://github.com/jwasham/google-interview-university) 這篇文章而被啟發。 402 | 我想要分享我的知識、經驗，並且告訴世人要如何成為一個底層程式語言開發者， 403 | 因為我發現這些知識，已經不像以前那麼常見。 404 | 此外，許多初學者及學生一直再問我，他們應該如何做才能成為底層程式開發者。 405 | 406 | 407 | 如果你想了解我？ 408 | 我是一位擁有 10 年底層程式開發經驗的程式設計師： 409 | 410 | * 80x86 組合語言程式開發 411 | * Atmel 晶片、硬體、韌體開發經驗 412 | * Unix 系統 C 語言開發經驗 413 | * Linux 驅動程式開發經驗 414 | * Linux 核心: page allocation 415 | * Linux 核心: 區塊設備、模組之驅動程式 -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-hacker --------------------------------------------------------------------------------