Это пробный урок. Оформите подписку, чтобы получить доступ ко всем материалам курса. Премиум

  1. Урок 1. 00:04:14
    Introduction
  2. Урок 2. 00:03:12
    What Is Memory?
  3. Урок 3. 00:07:06
    The Boot Process
  4. Урок 4. 00:02:31
    Installing What We Need For Real Mode Development
  5. Урок 5. 00:15:52
    Hello World Bootloader
  6. Урок 6. 00:04:50
    Understanding Real Mode
  7. Урок 7. 00:08:36
    Segmentation Memory Model
  8. Урок 8. 00:07:31
    Improving Our Bootloader
  9. Урок 9. 00:05:35
    Preparing our bootloader to be booted on real hardware
  10. Урок 10. 00:02:42
    Writing our bootloader to a USB stick
  11. Урок 11. 00:00:43
    Booting the bootloader
  12. Урок 12. 00:03:59
    The Interrupt Vector Table Explained
  13. Урок 13. 00:06:47
    Implementing our own interrupts in real mode
  14. Урок 14. 00:05:45
    Disk Access And How It Works
  15. Урок 15. 00:13:10
    Reading from the hard disk
  16. Урок 16. 00:06:35
    What is Protected Mode?
  17. Урок 17. 00:15:44
    Switching To Protected Mode
  18. Урок 18. 00:02:20
    Restructuring Our Project
  19. Урок 19. 00:02:37
    Enabling the A20 line
  20. Урок 20. 00:11:07
    Creating a Cross Compiler So We Can Code In C
  21. Урок 21. 00:38:39
    Loading our 32 bit kernel into memory and working with debugging symbols
  22. Урок 22. 00:01:25
    Cleaning our object files
  23. Урок 23. 00:07:28
    Dealing With Alignment Issues
  24. Урок 24. 00:08:04
    C Code In Protected Mode
  25. Урок 25. 00:02:36
    Text Mode Explained
  26. Урок 26. 00:16:27
    Writing To The Screen, Hello World Tutorial
  27. Урок 27. 00:08:34
    Interrupt Descriptor Table Explained
  28. Урок 28. 00:27:16
    Implementing The Interrupt Descriptor Table
  29. Урок 29. 00:09:46
    Implementing In and Out Functions
  30. Урок 30. 00:04:39
    Programmable Interrupt Controller Explained
  31. Урок 31. 00:12:31
    Programmable Interrupt Controller Implementation
  32. Урок 32. 00:20:24
    Understanding The Heap And Memory Allocation
  33. Урок 33. 01:04:42
    Implementing Our Heap
  34. Урок 34. 00:02:49
    Creating the enable interrupts function
  35. Урок 35. 00:20:02
    Understanding Paging
  36. Урок 36. 00:28:16
    Implementing Paging
  37. Урок 37. 00:23:03
    Modifying the page table
  38. Урок 38. 00:02:46
    Preparing To Read From The Hard Disk
  39. Урок 39. 00:10:35
    Reading from the disk in C with the ATA controller
  40. Урок 40. 00:09:42
    Improving Our Disk Driver
  41. Урок 41. 00:07:32
    What is a filesystem?
  42. Урок 42. 00:36:41
    Creating a path parser
  43. Урок 43. 00:15:45
    Creating a disk stream
  44. Урок 44. 00:18:01
    File Allocation Table Explained
  45. Урок 45. 00:14:00
    Starting To Create our FAT File system
  46. Урок 46. 00:06:36
    Understanding the VFS(Virtual File System) Layer
  47. Урок 47. 00:27:30
    Implementing our virtual filesystem core functionality
  48. Урок 48. 00:17:13
    implementing FAT16 filesystem driver core functionality
  49. Урок 49. 00:19:19
    Implementing FAT16 Structures
  50. Урок 50. 00:33:31
    Implementing The FAT16 Resolver Function
  51. Урок 51. 00:24:10
    Implementing the VFS fopen function
  52. Урок 52. 00:57:02
    Implementing FAT16 fopen function
  53. Урок 53. 00:06:07
    Implementing the VFS fread function
  54. Урок 54. 00:08:32
    Implementing FAT16 fread functionality
  55. Урок 55. 00:02:54
    Implementing the VFS fseek functionality
  56. Урок 56. 00:05:42
    Implementing the FAT16 fseek functionality
  57. Урок 57. 00:04:31
    Implementing the fstat VFS functionality
  58. Урок 58. 00:06:12
    Implementing the FAT16 fstat function
  59. Урок 59. 00:02:35
    Implementing the VFS fclose functionality
  60. Урок 60. 00:07:09
    Implementing the FAT16 fclose functionality
  61. Урок 61. 00:02:15
    Implementing a kernel panic
  62. Урок 62. 00:14:55
    Understanding User Land
  63. Урок 63. 00:19:04
    Changing our kernel segment and data descriptors to be written in C
  64. Урок 64. 00:11:59
    Implementing The TSS(Task Switch Segment)
  65. Урок 65. 00:29:50
    Implementing Task Foundations
  66. Урок 66. 00:38:11
    Implementing Process Foundations Part 1
  67. Урок 67. 00:24:30
    Implementing Process Foundations Part 2
  68. Урок 68. 00:01:10
    Packing the GDT
  69. Урок 69. 00:17:28
    Implementing User Land Functionality
  70. Урок 70. 00:09:08
    Creating our first user process application
  71. Урок 71. 00:07:56
    Executing the process and dropping into user land privileges
  72. Урок 72. 00:06:15
    Changing the paging functionality
  73. Урок 73. 00:20:15
    Talking with the kernel from userland
  74. Урок 74. 00:24:12
    Creating the interrupt 0x80 for user process to kernel communication
  75. Урок 75. 00:11:18
    Creating the ability to create and execute kernel commands
  76. Урок 76. 00:10:54
    Creating our first kernel command
  77. Урок 77. 00:06:47
    Calling our kernel command
  78. Урок 78. 00:14:37
    Copying strings from the tasks process
  79. Урок 79. 00:21:09
    Reading the task's stack
  80. Урок 80. 00:15:01
    Creating the print command in the kernel
  81. Урок 81. 00:15:16
    Understanding keyboard access in protected mode
  82. Урок 82. 00:15:46
    Creating the virtual keyboard layer
  83. Урок 83. 00:23:24
    Creating the PS2 port keyboard driver part 1
  84. Урок 84. 00:20:01
    Improving our interrupt descriptor table design
  85. Урок 85. 00:10:19
    Creating a cleaner way to create interrupt handlers in the interrupt descriptor
  86. Урок 86. 00:07:28
    Changing The Current Process
  87. Урок 87. 00:13:35
    Creating the PS2 port keyboard driver part 2
  88. Урок 88. 00:10:10
    Getting a key from the keyboard buffer in user land
  89. Урок 89. 00:06:54
    Creating a putchar command that writes one character to the terminal
  90. Урок 90. 00:03:05
    Implementing backspace in the terminal
  91. Урок 91. 00:06:28
    Revising our stream reader
  92. Урок 92. 00:22:11
    Elf Files Explained
  93. Урок 93. 00:18:46
    Implementing The Elf Loader - Part 1
  94. Урок 94. 00:23:46
    Implementing The Elf Loader - Part 2
  95. Урок 95. 00:04:21
    Implementing The Elf Loader - Part 3
  96. Урок 96. 00:17:14
    Implementing The Elf Loader - Part 4
  97. Урок 97. 00:28:59
    Implementing The Elf Loader - Part 5
  98. Урок 98. 00:13:44
    Implementing The Elf Loader - Part 6
  99. Урок 99. 00:14:50
    Writing User Programs In C
  100. Урок 100. 00:06:26
    Implementing system print in stdlib
  101. Урок 101. 00:02:57
    Implementing system get key in stdlib
  102. Урок 102. 00:21:45
    Implementing Malloc In Our stdlib
  103. Урок 103. 00:09:46
    Implementing Free In Our stdlib
  104. Урок 104. 00:02:13
    Changing the way we map virtual pages for the process
  105. Урок 105. 00:04:46
    Implementing itoa function
  106. Урок 106. 00:07:46
    Implementing the putchar function
  107. Урок 107. 00:06:38
    Implementing the printf function
  108. Урок 108. 00:10:13
    Implementing the ability to read lines
  109. Урок 109. 00:09:04
    Creating a shell
  110. Урок 110. 00:26:45
    Loading other programs from our shell
  111. Урок 111. 00:12:51
    Creating some important stdlib functions
  112. Урок 112. 00:08:45
    Memory Mapping malloc in stdlib
  113. Урок 113. 00:11:07
    Memory Unmapping free In stdlib
  114. Урок 114. 00:09:35
    Process arguments - Part 1
  115. Урок 115. 00:28:42
    Process Arguments - Part 2
  116. Урок 116. 00:05:39
    Process Arguments - Part 3
  117. Урок 117. 00:18:26
    Implementing A 'System' Command
  118. Урок 118. 00:15:20
    Implementing program termination
  119. Урок 119. 00:08:14
    Handling program crashes
  120. Урок 120. 00:05:47
    Creating an exit command
  121. Урок 121. 00:11:05
    Handling caps lock, upper case and lower case letters
  122. Урок 122. 00:06:45
    Running multiple tasks at the same time multi-tasking
  123. Урок 123. 00:01:22
    Changing our fat16_new_fat_item_for_directory_item function
  124. Урок 124. 00:03:28
    Changing our fat16_open function
  125. Урок 125. 00:02:18
    Changing our fat16_get_root_directory function
  126. Урок 126. 00:02:25
    Changing our process_load_binary function
  127. Урок 127. 00:08:22
    Improvements to our fat16_to_proper_string function
  128. Урок 128. 00:03:20
    Changing our restore_general_purpose_registers function
  129. Урок 129. 00:01:48
    What is assembly language?
  130. Урок 130. 00:02:01
    Installing the emulator
  131. Урок 131. 00:17:46
    Hello World In Assembly
  132. Урок 132. 00:12:57
    Transistors And Logic Gates Understanding The Processor
  133. Урок 133. 00:09:53
    Registers in the 8086
  134. Урок 134. 00:08:53
    Segmentation Memory Model Explained
  135. Урок 135. 00:08:39
    The Stack, Subroutines And Endiness Explained
  136. Урок 136. 00:06:38
    Bonus Lecture