We have at least 500 programming languages in existence today. 1 But why do we continue to invent them? Let’s talk! But first:
Computers are expensive and require extensive engineering effort to develop. As individuals, we invest hundreds of dollars 💲 each year in our personal computers, including laptops, gaming consoles, mobile phones, desktops, and more. But why? They must serve a purpose, correct? Indeed. Actually, each of these computers addresses a specific problem we encounter. Computers can perform complex mathematical computations, facilitate aircraft landings, entertain us, enable over-the-air communication, and even contribute to the discovery of planets in space! But how do they accomplish these tasks? What is the magic behind their functionality?
ENIAC, designed in 1945 to solve military-related problems, stands as one of the earliest computers (The whole thing in the room is a single computer. Power consumption was higher than 150 kW). With a cost exceeding 6 million US Dollars (adjusted for inflation), it was capable of performing only 5000 operations per second—a figure that may seem modest compared to today’s standards but still exceeded human capacity at the time. Photo
The magic lies in the ability to leverage information to accomplish these tasks. Computers possess memory to store information and fast communication links to facilitate the exchange of data. Ultimately, the crux of computer functionality revolves around the generation and processing of information.
Computers are incredible inventions created by smart people, but there’s no actual magic involved. They work because they’ve been carefully designed and engineered. If you want to experience something truly magical, consider exploring the wonders of nature through the study of natural sciences. 🪄
Nearly all problems solved by computers boil down to mathematical problems. Computers excel with numbers, capable of executing algorithms on data orders of magnitude faster than a human could. But how do they achieve this?
Processors serve as the heart ❤️ of computers (or brains 🧠, whatever organ you choose). A processor is an electronic hardware component capable of manipulating numbers at an incredibly high speed. While processors themselves can’t store data, they “process” (hence their name) the stored data, such as in RAM, and generate new data. They can achieve this at rates of billions of operations per second. Examples of processors include the CPU (Central Processing Unit), GPU (Graphics Processing Unit), and TPU (Tensor Processing Unit).
CPUs, or Central Processing Units, are general-purpose processors found in nearly all computers and many electronic devices. They are designed to handle a wide range of tasks, such as text editing, web surfing, and number crunching, typical of personal computers. Unlike specialized processors optimized for specific tasks, CPUs are not tailored to excel in any single function but rather are engineered to efficiently handle a variety of tasks.
The MOS Technology 6502 is a highly renowned microprocessor introduced in 1975, widely utilized in numerous microcomputers and video game consoles during the 1980s era. Capable of executing 1-2 million operations per second, it represented a significant leap in computing power compared to the 5000 operations per second capability of the ENIAC, which was designed in 1945. Despite its enhanced performance, the price of the 6502 remains relatively affordable, around $150 today when adjusted for inflation (originally $25 in 1975). Photo
GPUs, or Graphics Processing Units, differ from CPUs. While they are also processors, their internal architecture is specifically optimized to efficiently handle calculations required for graphical tasks. GPUs excel in processing graphical data by leveraging parallel computing, utilizing thousands of multiple processors designed to execute tasks simultaneously. Because neural network problems share a similar parallel nature to graphics tasks, GPUs are increasingly being utilized not only for graphical applications but also for solving AI problems. Nonetheless, they remain processors at their core.
The modern GPU card, Nvidia’s RTX 4090, released in 2022 for approximately $1600, boasts impressive capabilities. With its GeForce 40 series GPU, it can perform 73,000 billion single-precision floating-point operations per second while operating under 450W. Photo
TPUs, or Tensor Processing Units, are custom processors specifically designed for neural network applications. Developed by Google, TPUs are engineered to perform the mathematical operations necessary for neural network tasks more efficiently than GPUs. Unlike GPUs, TPUs are tailored solely for optimizing the performance of neural network computations.
Photo of TPUv3 processors. We can’t see them directly because they are under heatsinks. TPUv4 announced in 2021 is capable of doing 275,000 billion operations per second while operating under 170W. Photo
Microcontrollers, MCUs, present in nearly all electronic devices, also contain processors within them. In general, these processors are specifically designed to handle tasks that are not computationally intensive. However, certain microcontrollers are engineered to execute tasks with minimal power consumption, enabling devices to operate for years a single battery.
A PIC microcontroller from Microchip Technology. Photo
As evident, there exist numerous types of processors, beyond the examples provided, each tailored for specific purposes. Various companies are involved in the design and manufacturing of these processors. For instance, Intel and AMD are renowned for their CPUs, while Nvidia specializes in GPUs.
However, regardless of the type or manufacturer, all these processors fundamentally operate in a similar manner. The process of utilizing or programming them has remained essentially the same for decades, spanning across a wide range of processors.
Now that we’ve grasped the importance of the processor in a computer system,
whether it’s a CPU, GPU, TPU, or any other variant, let’s delve into its primary
functions. Broadly speaking, a processor performs two types of tasks:
arithmetic operations, which involve mathematical computations like
addition, multiplication, and division, and logical operations, which entail
making decisions based on conditions—for instance, determining if number A
is
greater than B
and taking appropriate actions accordingly. But how exactly do
we communicate with a processor to get our tasks done?
Let’s imagine that I’ve purchased an AMD Ryzen 7 8700G CPU from a computer store. This CPU, designed by AMD and released in early 2024, is capable of performing billions of operations per second, which is quite impressive. Now, let’s say I simply want to add two numbers together and obtain the result. How can I communicate this task to the CPU? How do I tell the CPU, “Hey, here are two numbers. Please add them together and return the result to me?”
AMD Ryzen 7 8700G. Photo by Tom’s Hardware.
As we’ve observed, there is a wide array of processors available today, each tailored to different applications with various optimizations such as power consumption and speed. Over the past 80 years, these processors have undergone dramatic changes in size, performance, and price. Comparing the computational power of a modern basic cell phone to that of the Apollo Guidance Computer, for example, would be practically meaningless. However, with all these historical advancements and variations, one fundamental aspect remains nearly unchanged: the basic operational principle of a processor.
Processors are essentially devices designed to execute tasks, functioning as an execution engine of sorts. Regardless of their processing power, a processor simply carries out the instructions it is given—no more, no less. We provide a list of commands, or instructions, to a processor, and it executes them one by one. Each instruction tells the processor precisely what action to take. A computer program essentially consists of an ordered set of instructions for the processor to follow. These instructions are stored in memory, typically RAM, and can be accessed by the processor. The processor then begins executing these instructions sequentially, from start to finish. Below is an illustration of how a program appears in memory:
Instruction 001: Do this
Instruction 002: Do that
Instruction 003: If A < N, do this otherwise do that
...
Instruction 875: Do this
Instruction 876: End
As you may have noticed, for a processor to be capable of performing useful tasks, it needs to support more than just one instruction. A processor that can only add two numbers together without any additional functionality wouldn’t be very practical, would it? Therefore, processors are designed to support a wide range of instructions, and the set of instructions supported by a processor is called its Instruction Set.
If you’re interested in this topic, you may have come across two terms: RISC
and CISC. In these terms, IS
in the middle stands for Instruction
Set. RISC stands for Reduced Instruction Set Computer, while
CISC stands for Complex Instruction Set Computer. Anyway, let’s
proceed with our exploration: talking with processors.
Let’s delve into instructions in more detail. As mentioned earlier, instructions are stored in memory and are accessible by the processor. Computers operate using numbers, binary numbers most of the time, which consist of 0s and 1s. This applies to both memory and processors. Each instruction communicates to the processor what action to take. To efficiently store these commands in memory, each command is encoded with a number. For instance, for a specific processor, reading a “01” from memory might indicate an addition operation, “10” for subtraction, “11” for comparison, and so on. In a moment, I’ll provide a real-life example from a processor to illustrate this further. Stay tuned!
Let’s examine a real-life example. To maintain simplicity and focus on the topic without getting distracted by advanced features implemented by a processor, I’ve chosen an old microcontroller from Microchip Technology: the PIC16F84. This microcontroller holds a special significance for me because it was the first microcontroller I programmed when I began experimenting with hobby electronics in high school.
PIC16C84 is an older version of PIC16F84. It was introduced in 1993. Photo
The datasheet of the PIC16F84 microcontroller is available on the manufacturer’s website. Let’s navigate to the “Instruction Set Summary” section, located on page 55, to gain insight into the instructions supported by this microcontroller.
This microcontroller consists of a CPU and an internal memory to store instructions that will be executed sequentially by the CPU. However, the memory structure is somewhat unusual because each row has a width of 14 bits. Typically, we are familiar with memories with widths that are multiples of 8 bits, such as 8, 16, or 32 bits. Nevertheless, there’s nothing inherently wrong with having a memory width of 14 bits. We can visualize the memory as follows:
Note that each row is filled with random 14-bit data just for illustrative purposes.
The internal program memory of the PIC16F84 is capable of holding 1024 instructions, each with a width of 14 bits.
On the same page, page 55, the instruction format is illustrated as follows:
PIC16F84 Instruction Format
The first notable aspect is that this particular processor can interpret four different instruction formats. Depending on the instruction category, each bit in the 14-bit word carries a distinct significance. Every instruction includes a common field known as OPCODE. All instructions supported by the processor are assigned a unique number, referred to as the OPCODE. The remaining bits may be interpreted differently by the processor based on the instruction, i.e., the OPCODE.
On the next page in the datasheet, Table 9-2 lists all instructions, i.e., the Instruction Set, along with their corresponding OPCODEs.
All instructions supported by PIC16F84
The PIC16F84 supports 35 distinct instructions. For humans, it is not practical to memorize the bit patterns for all instructions. Therefore, each instruction is assigned a nickname called a mnemonic. In this context, a mnemonic is the term for the instruction name.
Some instructions, like SLEEP
, don’t require any additional information from
the programmer. However, many instructions do need additional information to
operate. For instance, CLRF
is used to fill a memory location with all 0s.
However, we have to provide the address of the location, otherwise CLRF
won’t
know which memory location to clear. These additional parameters given with
instruction names are called operands in this context.
To delve deeper into the subject, let’s analyze an instruction thoroughly. Let’s
consider the ANDLW
instruction. The detailed explanation is provided on page 57
of the datasheet as follows:
The first 6-bit value, 111001
, represents the OPCODE of this instruction. The
remaining 8 bits constitute the single operand required for the instruction.
Essentially, the ANDLW
instruction performs a logical AND operation between
the content of the W
register and the constant value encoded in the 8-bit
operand field. The result is then stored back into the W
register.
Note that the
W
register is a special storage area found in the processor of this microcontroller. This name is specific to this processor, and other processors may have a different number of registers with different names. Therefore, don’t worry too much about this naming convention—it’s unique to this particular microcontroller.
The processor in the microcontroller essentially reads 14-bit wide instructions
from the program memory, row by row. Let’s say the processor reads the value
11100100010010
. When we split this value, we have 111001
concatenated with
00010010
. This represents the ANDLW
instruction with an operand value of
0x12 (in hexadecimal, 18 in decimal). When the processor reads this particular
14-bit value, it performs a logical AND operation between the value stored in
the W
register and 0x12, and then writes the result back to the W
register.
The program memory could be like this:
<14-bit wide instruction>
<14-bit wide instruction>
...
11100100010010 -> ANDLW 0x12
...
<14-bit wide instruction>
If you continue reading the remaining part of the datasheet, you’ll notice that each instruction is explained in detail. Similarly, all processors have similar documents that explain each instruction and its effects on the state of the processor (such as registers).
The set of instructions + the architecture that behaves according to those instructions is referred to as the Instruction Set Architecture (ISA).
In summary, processors only understand instructions, often accompanied by operands. To achieve meaningful outcomes, programmers must provide instructions in a logical order. Processors lack awareness of the tasks they are performing (such as calculating the Fibonacci Sequence); it is the programmer’s responsibility to ensure that the set of instructions executed by the processor yields a meaningful result. This result may be stored in main memory, such as RAM. Importantly, processors do not understand programming languages like JavaScript, Python, or C. They can only execute instructions stored in memory, supported by their own ISA, one by one, without deviation.
Commonly, ISA is defined as the contract between software and hardware. Considering ISA as an agreement between hardware and software people is a very apt representation. Let’s explore why.
In the previous example, we explored the ISA implemented by Microchip company in the PIC16F84 microcontroller. However, we didn’t delve into the internals of the processor. We don’t know how Microchip uses flip-flops and transistors to build the processor. We don’t know how the logical AND operation is implemented at the transistor level, and we don’t need to! The only thing we need to utilize a processor designed by a company is the details explained in the ISA.
The concept of ISA is similar to API (Application Programming Interface) in the software world. As programmers who are willing to utilize existing processors, rather than design them, we only need to know how to use them, not their internal structure. As long as processor manufacturers adhere to the rules defined in the corresponding ISA, they are free to design whatever circuit they like, and programmers won’t notice any difference.
ISA is the contract between software and hardware. Taken from Onur Mutlu’s lecture slides.
Processor design companies, also known as hardware companies, have the flexibility to design processors with vastly different internal architectures while still supporting exactly the same ISA. These differences in internal structures can result in the design of processors that are more power-efficient, faster, or cheaper.
The contrast between two processors supporting the same ISA can be significant. One processor may be widely adopted and used in numerous systems, while the other may not be used at all, potentially leading to financial crises within a company.
In summary, the metrics of two processors can be dramatically opposite, even if they implement the same ISA.
Okay, we understand that in order to utilize a processor and write programs that perform valuable tasks, we have to study the ISA of the processor and program it accordingly. But how many ISAs are currently in use? Can we talk about a universal ISA that all processors support, so we as programmers can learn one ISA to work with all processors?
The bad news is that there is not just one ISA, I’m afraid. Since the inception of the first electronic processors, companies began developing their own ISAs. Therefore, we can’t talk about a universal ISA. However, the good news is that processors are grouped together in such a way that a group of processors implements the same ISA. So, the number of ISAs is less than the number of designed processors.
For example, as programmers, we don’t need to learn a different ISA for each CPU designed by Intel; fortunately, they share a common ISA base.
The term architecture commonly refers to the ISA implemented by a processor. From a CPU standpoint, common architectures (ISAs) include ARM (v7, v8, v9…), x86, x86-64, MIPS, RISC-V, etc. For example, there are multiple processor design companies designing ARM CPUs. From a programmer’s viewpoint, instructions suitable for the ARMv7 ISA, for instance, can be executed on CPUs from both companies.
Today, many architectures (ISAs) have “plugin” capabilities. While maintaining the base instructions as a minimum requirement, a vendor may implement additional instructions. These additional instructions are often referred to as extensions.
For example, ARM has SVE (Scalable Vector Extension) to implement fast vector-based operations. If a program uses these kinds of extensions, these instructions won’t work on a similar processor lacking that extension.
Until now, we’ve assumed that instructions executed by the processor are available in the memory somehow. But how do we actually put those instructions into memory?
In today’s computers, when we double-click an application, the instructions for the application are loaded into memory by the operating system (OS). We don’t even think about the process of reading instructions from disk and putting them into memory (RAM) and letting the CPU run the instructions. However, this process wasn’t as trivial in the old days as it is today.
Many old computers lacked an operating system to read instructions from storage and load them into memory. Some had operating systems available, but the cost of operating systems or computers capable of running them was prohibitively high, so people often didn’t choose those systems. Additionally, storing programs on paper (punch cards) could be cheaper than storing them on hard disks. Since this subject is beyond the scope of this post, I won’t go into details, but if you’re interested, I recommend watching the following video:
and
As an example, I would like to talk about the Altair 8800. According to many resources, it is considered the first personal (micro)computer. 2 It features an Intel 8080 processor and was designed by MITS in 1974. The Altair 8800 played a significant role in the history of Microsoft and Apple.
Did you notice something? This computer doesn’t have a keyboard, mouse, or screen! How are you supposed to program it? Well, you would use the front panel, which consists of a bunch of switches and LEDs, and perform something called Front Panel Programming.
By toggling switches, a programmer inputs 0s and 1s into the memory, which are
then read by the processor. After inputting all instructions one by one and
hitting the RUN
button, the processor executes the instructions stored in the
memory. After running all instructions, the results can be read back by toggling
switches and observing LEDs.
This is how a “real programmer” operates a computer!
and
As you can see, we communicate with computers via instructions given in the corresponding ISA. The instruction set resembles a dictionary for a language that a processor can understand. This language, which a processor can understand or “speak,” is called machine language. Communicating with a processor, or with a more technical term, programming it with raw instructions using 0s and 1s, is called machine language programming. Programming a computer with 0s and 1s directly is the lowest level of programming possible. Machine language is also known as machine code.
In programming terminology, we have low-level and high-level languages. Low-level languages are closer to the machine than to a human. On the other hand, high-level languages are more suitable for humans; they resemble natural human language more than machine language.
Clearly, programs written with 0s and 1s are very close to machines but not to humans. However, this is what computers or processors understand: 0s and 1s.
Although programming a computer with machine language is a natural way of programming from the perspective of a processor or computer, understanding a bunch of 0s and 1s put together isn’t an easy task for a human. A programmer needs to communicate with colleagues, review code, and so on. However, trying to understand 0s and 1s and writing programs with them is error-prone and a very time-consuming task.
So instead of writing programs in 0s and 1s, why can’t we write them in a more human-readable way and then convert them to 0s and 1s that a processor can understand? This is exactly how assembly languages work!
🤔 Trivia: It is believed that the first assembler program was developed for a British computer known as EDSAC in 1949. 3
If you remember, we defined two terms with the PIC16F84 example: mnemonic and
operand. Instead of writing raw 0s and 1s, we can write instructions using
“nicknames” of instructions like ADD
, SUB
, GOTO
, CLRF
, etc. Then, a
computer program called an assembler converts those words into 0s and 1s
that a particular CPU can understand. Programmers can interpret words like ADD
more easily than 000100101
, right?
An assembler serves a broader purpose beyond simply translating words into 0s and 1s. I’ll delve deeper into this concept with an explanation using a specific assembly program designed for the PIC16F628, a well-known microcontroller from Microchip.
CNTR1 EQU H'20'
CNTR2 EQU H'21'
CLRF PORTB ; Clear PORTB
BANKSEL TRISB
CLRF TRISB
BANKSEL PORTB
LOOP
MOVLW h'00'
MOVWF PORTB
CALL DELAY
MOVLW h'FF'
MOVWF PORTB
CALL DELAY
GOTO LOOP
DELAY
MOVLW h'FF'
MOVWF CNTR1
LOOP1
MOVLW h'FF'
MOVWF CNTR2
LOOP2
DECFSZ CNTR2, F
GOTO LOOP2
DECFSZ CNTR1, F
GOTO LOOP1
RETURN
END
This code doesn’t accomplish anything particularly useful; it simply sets some registers and then loops through two nested loops. However, the intention here is to illustrate the structure of an assembly language program.
Most of the lines in the program correspond to a single instruction for the
processor, such as MOVLW
, MOVWF
, and CALL
. Some of them are included for
the sake of simplicity in creating assembly programs.
For example, CNTR1 EQU H'20'
creates a substitution word CNTR1
, which will
be replaced by 0x20
when the assembler converts the program into 0s and 1s
that the processor can understand. This functionality is very similar to the
#define CNTR1 0x20
preprocessor directive in C. The same concept applies to
CNTR2
, PORTB
, and TRISB
. This feature of the assembler simplifies
modifications to the program. Instead of writing 0x20
everywhere and then
performing a search-and-replace, one can easily change CNTR1 EQU H'20'
to
another value if needed. The definitions for PORTB
and TRISB
are provided by
the vendor so that the user doesn’t need to memorize the actual register
addresses.
Another feature commonly supported by assemblers is the use of labels. DELAY
,
LOOP
, LOOP1
, and LOOP2
are labels. When a label is used with an
instruction like GOTO
, the assembler automatically calculates the address of
the instruction labeled by the label and generates the correct instruction that
directs the processor to start executing that instruction. This simplifies the
programmer’s life, as otherwise, the programmer would need to manually calculate
offsets between instructions.
Many assemblers offer features to fill a memory region with text, typically represented in ASCII, along with other handy functionalities. However, an assembly language for a processor strictly adheres to its ISA and machine language specifications. These additional features simply make a programmer’s life a bit easier. Since assembly language closely mirrors machine language with some helpful additions, it is also referred to as symbolic machine language or symbolic machine code. While we write programs in a manner similar to machine language but we use symbols to create them. Ultimately, the assembler converts the program into machine language, consisting solely of 0s and 1s.
Since assembly languages strictly adhere to the instructions defined in a
particular ISA, we have different assembly languages for each architecture.
Let’s write a very simple function for different architectures. The function takes
two inputs and calculates the sum of their squares: x^2 + y^2
.
For x86-64 architecture:
mov eax, DWORD PTR [rbp-20]
imul eax, eax
mov edx, eax
mov eax, DWORD PTR [rbp-24]
imul eax, eax
add eax, edx
mov DWORD PTR [rbp-4], eax
For RISC-V 64-bits architecture:
lw a5,-36(s0)
mulw a5,a5,a5
sext.w a4,a5
lw a5,-40(s0)
mulw a5,a5,a5
sext.w a5,a5
addw a5,a4,a5
sw a5,-20(s0)
and for MIPS:
lw $2,24($fp)
nop
mult $2,$2
mflo $3
lw $2,28($fp)
nop
mult $2,$2
mflo $2
addu $2,$3,$2
sw $2,8($fp)
As you may easily notice, the same functionality is achieved with different assembly programs for different architectures. Since their ISAs are different, the corresponding assembly programs also differ. Although all of them share a similar pattern and some instructions appear similar, one has to learn each assembly language for the processors they work on.
A similar issue persists even when working with very similar processors. Let’s consider another example. In this case, assume we have three variables, x, y, and z, and we aim to implement z = x + y, where all of them are integers with a width of 64 bits.
For ARMv7:
ldr r1, [sp, #16]
ldr r0, [sp, #20]
ldr r3, [sp, #8]
ldr r2, [sp, #12]
adds r1, r1, r3
adc r0, r0, r2
str r1, [sp]
str r0, [sp, #4]
For ARMv8:
ldr x8, [sp, #24]
ldr x9, [sp, #16]
add x8, x8, x9
str x8, [sp, #8]
The assembly programs for both architectures are very similar; they both contain
almost the same instructions. However, the program for ARMv8 has almost half the
number of instructions compared to the program for ARMv7. This is because ARMv8
is a 64-bit processor architecture, and since the “natural” word length of this
architecture is 64 bits, a single add
instruction is sufficient to sum up two
64-bit variables. On the other hand, ARMv7 is a 32-bit processor architecture
and cannot handle 64-bit variables as easily as ARMv8. Therefore, one has to
split a 64-bit variable into two 32-bit variables and perform multiple
additions.
As you can see, programming in assembly language is easier than programming in machine language. However, one must learn the ISA for each architecture and consider other factors such as variable sizes and architectural details. Let’s imagine that you’ve written a fairly large assembly program for the ARMv7 architecture, and one day you need to run the same program on an x86-64 architecture. In that case, you would have to rewrite your program in x86-64 assembly language. Rewriting the same program for a different architecture or system is known as porting. At the assembly language level, porting is not an easy task because you have to rewrite the entire program again. If you are supposed to port the same program to five different architectures, good luck! You will have to rewrite and debug the same program five times using different assembly languages.
As we conclude this section, it’s important to recognize that even within the same architecture, there can be multiple assembly language variants. Take x86 assembly, for instance, where two prominent styles exist: AT&T and Intel. 4 While these styles may appear similar, they differ in the order of instruction parameters. Nevertheless, despite these variations, they ultimately produce the same machine code.
This concludes part 1. In part 2, we’ll explore what can be built on top of assembly language, and I’ll share my personal insights on the existence of various programming languages. Stay tuned for more!
]]>Kapak fotosunu DALL-E çizdi. Çalışma ortamıma benzeyen tek şey Ankara’nın da bugün güneşli olması…
Hafta sonunun verdiği boşlukla uzun zamandır yapmayı düşündüğüm bir işi yapmaya karar verdim. Bir yandan da bu blog yazısına yaptıklarımı not alayım dedim.
2012’de aldığım, hala çalışan ve arada bir kullandığım bir Samsung marka laptop’um var. Zamanına göre iyi bir bilgisayardı, 8G RAM, 1TB HDD ve Intel i7-3610QM işlemci (Spectre ve Meltdown açıkları var diye kullanmayı bırakacak değilim). Dual Boot olan bu laptop’un bir tarafı Windows 10, bir tarafı ise GNOME masaüstü ile Debian Buster (10). Son Buster sürümü olan 10.13, Eylül 2022’de yayınlandı, bu sürüm Haziran 2024 sonuna kadar ise LTS projesi kapsamında destekleniyor 1. Anlayacağınız artık yolun sonuna geldim.
Windows 10’u kullanmak imkansız. Belki şaka gibi gelecek ama laptop’un HDD’si o kadar düşük bir performansa sahip ki (+ fazla açılış uygulaması ve optimize edilmemiş şeyler olabilir, kabul) Windows 10’un açılıp, kullanılabilir hale gelmesi 45 dakika sürüyor. Evet, tam 45 dakika. Ama hala yanımda götürdüğümde bir yerde ihtiyaç olur diye Windows’u tutuyorum. Hoş, kullanması imkansız olsa da. Laptop’u zaten çok az kullanıyorum, onda da Debian’ı kullanıyorum.
XFCE gibi masaüstü ortamı yerine GNOME kullanmam garip gelmiş olabilir. GNOME pek sevilen bir masaüstü ortamı değil (nerede o eski GNOME 2). Özellikle benim laptop’um gibi kaynağı az olan bilgisayarlar için pek de önerilmez. Kullanıcıya pek değiştirme seçeneği sunmadığı ve tablet arayüzü gibi bir arayüz sunduğu söylenir. İşte tam da ben bundan dolayı laptop’ta GNOME kullanıyordum. Çünkü bu benim ana çalışma bilgisayarım değil, 1-2 adet programı beraber ya açıyorum ya açmıyorum. Küçük ekranda, o “tabletvari” arayüzü bana kullanışlı geliyordu. GNOME’ın kendi yazılımlarının birbiriyle çok iyi entegre çalışmasını da seviyorum (keyring vs). Milletin bayıldığı KDE’yi de ben bir türlü sevemedim. O kadar çok fazla ayar var ki onlar olunca hepsini kurcalamadan rahat edemiyorum. GNOME adeta “Kullan geç” diyor. Ama çoklu ekranlı esas kullandığım masaüstü bilgisayarımda da GNOME çok sade kalıyor, yani kullanışsız oluyordu. Orada da XFCE gibi ortamları seviyorum. Laptop’taki 8 GB RAM, üzerinde çalışan az sayıda programı düşününce GNOME açısından problem olmuyor.
Linux dağıtımlarını içeriden upgrade etmeyi pek sevmiyorum. Üniversite yıllarımda Ubuntu’yu upgrade ederken yaşamış olduğum tramvalarım var. Şu an daha düzgündür muhtemelen ama birkaç yılda bir format atmak bence bir temizlik yapmak için de fırsat oluyor.
Bir aralar tam bir Distrohoper dım. O Distro senin bu Distro benim atlar
dururdum. Arch Linux gibi dağıtımları sevsem de artık yaşlandım ve dağıtımın
çıkartabileceği problemlerle uğraşmak istemiyorum. Siz Arch Linux ile hiç
problem yaşamamış olabilirsiniz ama ben ne zaman kullansam birkaç aya kalmadan
patlıyorum kardeşim! Projeyi ve arkasındaki mantığı (ve elbette Wiki’sini) çok
sevsem de Virtualbox dışında artık bir yere kurmak istemiyorum. O yüzden
laptop’ta da zamanında Debian tercih etmiştim. İş ve evi ortaklamak için artık
Debian temelli sistemlerden devam ediyorum (Evet, apt
en iyi paket yöneticisi
olmayabilir ama, hayat işte…). Bir ara laptop’ta Fedora kullanıyordum, o da
çok tatlı ve acayip güncel bir distro.
Bu sefer Linux Mint’e şans vermek istedim. Bir süredir başka bilgisayarlarda kullanıyorum, hoşuma gidiyor. Bu sefer Linux Mint 21.3 Virginia Xfce Edition kuracağım.
Debian 10 kurarken dm-crypt
(?) ile disk şifreleme (sonuçta laptop) ve üzerine
LVM vs kurabilmiştim. LVM’i niye kurdum bilmiyorum ama neden olmasın? Mint’te de
benzer bir kurgu oluşturabileceğim bence. Ha bir de laptop’u uykuya yatırmak
için RAM’in sığabileceği bir şifreli Swap alanı. Bunlardan bir miktar
vazgeçebilirim, yükleyicinin advanced mode’unu açıp uğraşasım yok ama içinme
sinmeyecek bir noktaya gelirse yani Linux Mint’te bunları kolayca yapamazsam
Debian 12 basar geçerim. (Direkt öyle mi yapsam acep? Neyse…)
Disk layout’um şöyle bir şey(miş):
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 931.5G 0 disk
├─sda1 8:1 0 450M 0 part
├─sda2 8:2 0 100M 0 part /boot/efi
├─sda3 8:3 0 16M 0 part
├─sda4 8:4 0 389.6G 0 part
├─sda5 8:5 0 518M 0 part
├─sda6 8:6 0 550M 0 part
├─sda7 8:7 0 2G 0 part /boot
├─sda8 8:8 0 493.8G 0 part
│ └─sda8_crypt 254:0 0 493.7G 0 crypt
│ ├─vg-lv_swap 254:1 0 15.3G 0 lvm [SWAP]
│ └─vg-lv_root 254:2 0 478.5G 0 lvm /
└─sda9 8:9 0 44.6G 0 part
Bir süredir rolling release gibi Debian
testing
mi kullansam diye düşünmüyor da değilim, kullanlar stabilitesini seviyor. Debian’ıntesting
i, Arch’tan stabil diyenler var, lol, ama bu çok bel altı!
Goygoyumuzu da yapalım
~
dizinimi biraz temizledikten sonra taşımak istediğim dosyaları tar.xz
ile
sıkıştırıyorum ve SFTP üzerinden başka bir bilgisayara alıyorum. Format sonrası
(muhtemelen bir daha asla açmamak üzere) yeni ~
dizinime getireceğim.
Gelelim kurulum USB belleğimizi hazırlamaya. Bu tarafta kısa bir süredir
Ventoy yazılımını kullanıyorum, yeni keşfettim
sayılır. Normalde indirdiğimiz ISO’yu yazıyorduk USB belleğe, dd
ya da
Windows’ta Rufus ile falan. Ventoy’un ise kendi bir
“bootloader”ı var, içine birden fazla ISO atabiliyoruz ve açılışta istediğimiz
ISO’yu seçebiliyoruz. Ayrıca büyük bir bellek ise, kalan kısmını normal USB
bellek gibi de kullanabiliyoruz. Hani derler ya, Linux ile uğraşanlar ya da
sistem yöneticileri yanında USB bellek ile her zaman bir Linux kurulumu ya da
Live ISO taşısınlar diye, işte Ventoy ile tek USB bellek ile yanınızda bir sürü
ISO taşıyabilirsiniz. Kullanmıyorsanız, muhakkak bakın.
Bendeki manzara şöyle:
Burada USB belleğiniz normal bir bellek gibi gözüküyor aslında. ISO
klasörü
içerisine istediğim ISO’ları koyuyorum. Dikkat ederseniz dosyalar açılmış yani
belleğe yazılmış halde değil, internetten indirildiği gibi duruyor.
Boot ettikten sonra Ventoy’un ekranı geliyor ve kullanmak istediğimiz imajı seçiyoruz.
Linux Mint’in kurulumunda merak ettiğim kısım eski disk layout’umu yapıp
yapamayacağımdı ve yapamadım. Şifreli bölüm üretebildim ama LVM yapamadım,
ayrıca farklı partition’lar da yaratamadım. Kendisi şifrelediğim diski otomatik
olarak ext4
olarak formatladı. Formatı değiştirmek mümkündü ama sdax_crypt
altında oluşan diskin altına birden fazla partition oluşturamadım. Ben GUI’de
görememiş olabilirim, bakındım ama… Bir dediğim gibi “advanced mode” gibi bir
şeyle de uğraşmak istemedim, var mı onu bile bilmiyorum.
Onun dışında kurulum standard Ubuntu kurulumu.
Linux Mint’in en güzel özelliği kullanışlı ve tema açısından da güzel bir entegrasyon sağlanmış iyi bir masasüstü deneyimi sağlaması. Bu konuda da yine beni hoşnut etti. Benim ekranıma göre biraz yazılar küçük geldi ama bunlar kolayca ayarlanacak şeyler (ayarlamadım).
FAKAT disk layout’umu istediğim gibi yapamadığım için hibernate yapamıyorum. Bunun böyle olabileceğini kurulum sırasında fark ettim fakat laptop’u çok az kullandığım ve bu kullanımların da çok azında hibernate yaptığım için (yani kapağı kapatıp, sistemi komple diske kaydetme ve laptop’un gücünü tamamen kapatabilme) bunu göze alarak kuruluma devam ettim. Ventoy’un sayesinde diskte Debian olmasına rağmen, ki zamanında Debian kurulumunda bu disk layout’unu yapabilmiş (gösterdiğim üzere) ve hibernate desteği getirebilmiştim, hem üşendiğimden (tekrar reboot falan) hem de Linux Mint’i de laptopta biraz denemek istediğimden devam ettim.
$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS
sda 8:0 0 931,5G 0 disk
├─sda1 8:1 0 450M 0 part
├─sda2 8:2 0 100M 0 part /boot/efi
├─sda3 8:3 0 16M 0 part
├─sda4 8:4 0 389,6G 0 part
├─sda5 8:5 0 518M 0 part
├─sda6 8:6 0 550M 0 part
├─sda7 8:7 0 2G 0 part /boot
├─sda8 8:8 0 493,7G 0 part
│ └─sda8_crypt 253:0 0 493,7G 0 crypt /
└─sda9 8:9 0 44,6G 0 part
sr0 11:0 1 1024M 0 rom
Yeni layout’ta Swap, LVM falan hak getire…
Bana ilginç gelen, Hibernation özelliğinin Mint forumlarında hala istenen özellik olarak tartışılıyor olması oldu. 2 Masaüstü kullanımı (yani server amaçlı olmayan, laptop dahil) amaçlayan bir dağıtımın böyle bir özelliği bence desteklemesi gerekiyor. Öte yandan, Suspend özelliği var. Burada, Hibernate’ten farklı olarak laptopun kapağı kapatıldığı zaman (ya da elle bu moda sokulduğu zaman) bilgisayar uykuya geçerken bilgileri RAM’de “donduruyor.” Ama RAM’in çalışması için, bilgisayarın az da olsa biraz güç tüketmesi gerekiyor. Laptop güçteyse problem yok, pilden çalışıyorsa yine saatlerce hatta günlerce bu modda kalabiliyor. Hibernate ise “derin uyku” olarak düşünülebilir. RAM’e kaydedilmek yerine, diske kaydediliyor bilgiler. Bunun için disk partition’larının uygun olması gerekiyor (swap alan, şifreli alan vs…). Bu durumda bilgisayar komple kapatılabiliyor. Bu da teoride sınırsız bir uyku süresi demek. Bu açıdan düşününce çoğu durumda Suspend yeterli, sonuçta pili olan bir laptop bu durumda çok rahat saatlerce durabilir. Ama yine de masaüstü kullanımı hedefleyen bir dağıtımın Hibernate’i “out-of-box” desteklemesi gerekirdi bence. Sunucu kullanımı hedefleyen dağıtımlar için bu zaten anlamlı değil.
Suspend ve Hibernate’ten konuşunca, 10 yıl önce yazdığım şu yazı aklıma geldi. Hey gidi günler…
Benim kurduğum Linux Mint XFCE dağtımında laptop prizdeyken ekranı kapatmak (fiziksel olarak) sadece ekranı kilitliyor, bunu Suspend olarak değiştirdim ve biraz denedim. Suspend’e giriş çıkışta bir problem görmedim, Wi-Fi dahil.
Laptop’ta olan Realtek entegreli ağ arayüzleri için bir sürücü kurmam gerekmedi. Debian’da ayrıca kurmuştum fakat bu Debian’ın sadece repo lisans politikası ile ilgiliydi sanırım, Linux Mint (yani Ubuntu) bu konuda daha “gevşek” olabilir.
$ free -h
total used free shared buff/cache available
Mem: 7,6Gi 1,6Gi 552Mi 300Mi 5,6Gi 5,5Gi
Swap: 2,0Gi 0B 2,0Gi
$ swapon -s
Filename Type Size Used Priority
/swapfile
Bu arada, kurulum sırasında bir Swap alanı oluşturmasam da otomatik olarak
2GB boyutunda /swapfile
oluşturulmuş. Diskim geniş ve RAM’im görece az
olduğu için ben RAM boyutunda yani 8GB boyutunda bir Swap oluştururdum bu
sistem için ama pek bir uygulama da çalıştırmadığım için buna dokunmayacağım.
Linux Mint’in varsayılan masaüstü ortamı Cinnamon, aynı topluluk tarafından geliştiriliyor. Bunun dışında MATE ve Xfce de destekleniyor, buradan bakabilirsiniz. İşin güzel yani, tüm masaüstü ortamlarının neredeyse aynı görünecek şekilde ayarlanmış olması. Linux Mint’in yaşattığı masaüstü deneyimi gerçekten güzel. Ubuntu temelli olması da bir şeyleri kurmak ve uyumluluk açısından iyi bir avantaj sağlıyor. Ayrıca otomatik sürücü bulması, özellikle NVIDIA kullanıcıları için bir kolaylık. Benim laptopta da çok eski bir ekran kartı olsa da varsayılan açık kaynak sürücüden devam ediyorum şimdilik.
Laptop’u pilde çok sık kullansaydım güç tüketimini optimize etmek adına başka dağıtımlara bakabilir ya da kernel ayarları ile oynayabilirdim. Ama ben neredeyse hep prizde kullandığım için buraları kurcalamıyorum.
Şöyle bir saflık yaptım: Linux Mint, Ubuntu 22.04 temelli ve Nisan 2027’ye kadar desteklenecek. Biraz daha bekleseydim ki, Debian 10 Debian LTS projesi tarafından Haziran 2024’e kadar desteklenecek, yeni LTS sürümü olacak Ubuntu 24.04 temelli yeni Linux Mint’i kurabilirdim. Bu da muhtemelen 2029’a kadar destekleniyor olacak, böylece 2 sene daha kazanırdım. Neyse 2027 uzun bir süre, daha 3 yıl var…
Format sonrası kullandığım yazılımları ve temaları kuracağım, birazcık daha işim var. Belki bu aralar uğraştığım Buildroot Öğreniyoruz serisine de buradan devam ederim? Bilmeyenler için an itibariyle serideki son yazım:
İlerleyen zamanlarda karta bir şeyler atmak için SD Card arayüzüne ihtiyacım olacak. Bu da esas masaüstü çalışma bilgisayarımda yok, bir tek bu laptop’ta var. Derlenmiş dosyaları taşımak yerine, direkt laptop üzerinde de çalışabilirim belki. Bir düşüneyim…
Sizin de benim gibi “patates” bilgisayarınız varsa şu videoya bakabilirsiniz:
]]>İçerik, bu sayfadaki yazıların üzerine anlatım yapılarak video olarak sunulmuştur. Her ne kadar yazı ile video içerik benzese de vaktiniz var ise videoyu izlemenizi tavsiye ederim, çünkü bazı noktalarda yazıda olmayan yorumlar yapıyorum.
Buildroot yolculuğumuza, Buildroot Öğreniyoruz serisinin 4. bölümü ile devam ediyoruz. Bu bölümde, Buildroot ile ilk derlememizi yapacağız. Bir önceki bölümde, Buildroot ile tanışmış, tasarım felsefesine, kimler tarafından kullanıldığına ve nasıl kullanıldığına bakmıştık. Bu bölümde ise, bir önceki bölümde öğrendiklerimizin adeta pratiğini yapacağız. Eğer bir önceki bölümü izlemediyseniz konu bütünlüğü açısından önceki bölüme bakmanızı öneririm. 👇
Önceki bölümde, Buildroot’un bir Linux dağıtımı üzerinde çalıştığından bahsetmiştik.
Buildroot bir Linux dağıtımı oluşturma aracı fakat kendisi de Linux üzerinde çalışıyor. 🐧
Günlük yaşantısında zaten Linux ile çalışan arkadaşlar, kendi işletim sistemlerinde çalışmaya devam edebilirler. Birazdan değineceğiz ama Buildroot’un çalışmak için talep ettiği bileşenler (paketler) oldukça genel, herhangi bir dağıtıma bağımlılığı bulmuyor. O yüzden zaten bir Linux dağıtımı (Ubuntu, Linux Mint, Pardus, Fedora, Arch (BTW)) üzerinde çalışıyorsanız devam edebilirsiniz.
Windows üzerinde çalışan arkadaşlar için ise durum biraz farklı. Önceki
bölümde, WSL yani
Windows Subsystem for Linux ile tek bir deneme yaptığımdan ve bu denememde
/dev/pts
kaynaklı çeşitli uyarı mesajları aldığımdan bahsetmiştim. Windows
üzerinde çalışacak arkadaşlara (ben de kullanıyorum),
Virtualbox yazılımını önermiştim.
Buildroot’un, WSL üzerinde çalıştırılması ile ilgili çeşitli tartışmalar ve blog yazıları internette mevcut. Son sürümlerinin WSL ile çalıştığını okusam da ben WSL üzerinden devam etmeyeceğim. Bu seri boyunca duruma göre ya bir Linux dağıtımı ya da Windows üzerinde Virtualbox üzerinde çalışacağım. Sizlere de Virtualbox kullanmanızı öneririm.
Bağlantısı verdiğim Reddit tartışmasından bir yorum. Ben de aynı fikirdeyim ama size karışamam. 😝
VirtualBox, bilgisayarınızda sanal bilgisayarlar oluşturmanızı sağlayan bir yazılım. Windows ve Linux üzerinde çalışabiliyor. Buildroot serisi özelinde, zaten Linux bir makineniz varsa üzerine tekrar Virtualbox ile bir sanal makine daha oluşturmanıza gerek yok.
Önceki bölümde, Virtualbox kurulumunu göstereceğimi söylemiştim. Sonra tekrar düşündüm de, her yerde bulabileceğiniz bu bilgiyi (içeriği kısa tutmak adına da )benim tekrar anlatmama gerek yok. Buildroot için herhangi bir Linux dağıtımı kullanabilirsiniz. Tipik olarak Ubuntu 22.04 LTS veya en güncel sürüm olan Ubuntu 23.10 tercih edebilirsiniz. Ben Ubuntu 22.04 kullanacağım.
Virtualbox üzerinde Ubuntu 22.04 kurulumu ile ilgili YouTube üzerinde de birçok anlatım mevcut. Hangi dağıtımı kurarsanız kurun, zaten süreç benzer olacaktır.
Bilgisayarınızın gücüne bağlı olarak istediğiniz kaynakları verebilirsiniz ama ben 50-100 GB arası bir disk tahsis etmenizi öneriyorum.
Ben ise 8 çekirdek, 6 GB RAM ve 100 GB disk verdim. Virtualbox’ta preallocate
demediğiniz sürece disk 100 GB (ya da ne seçtiyseniz) gözükse de diskinizde
fiziksel olarak bu kadar yer kaplamayacak, kurduğunuz sanal makine diski
kullandıkça diskinizdeki sanal disk dosyası büyüyecektir. Tahmin ediyorum ki
Buildroot derlenirken birden fazla çekirdek kullanabiliyordur. Bu yüzden CPU ve
RAM’i ne kadar fazla verirseniz derleme süreleri muhtemelen kısalır.
Ubuntu’yu Minimal Installation
ve güncellemeleri kurulum
sırasında yükleyecek şekilde kurdum. Siz diğer seçenekleri de tercih edebilirsiniz.
Bilgisayarınıza (temelde SSD vs HDD) göre değişkenlik gösterecek olmasına rağmen kurulum yaklaşık 10-20 dakika sürmektedir. Kurduktan sonra,
sudo apt update
sudo apt upgrade
ile sisteminizi güncelleştirmenizi öneririm.
Sanal makine deneyiminizi iyileştirmek için (ekran çözünürlüğünü dinamik olarak büyütme, dosya ve pano (clipboard) paylaşımı gibi) VirtualBox Guest Additions kurmanızı öneriyorum. Yine YouTube üzerinden izleyebilirsiniz.
Bu noktadan sonra sanal veya gerçek bir Linux makine üzerinde çalışabildiğinizi varsayıyorum.
Ben de yeni kurulmuş bir Ubuntu 22.04 üzerinden anlatımıma devam edeceğim.
ℹ️ Yazının devamında bulacağını ekran kayıtları ve görüntüler farklı farklı olabilir. İçeriği uygunluk durumuma göre başka bilgisayarlar üzerinde hazırlıyorum. Sizin açınızdan değişen bir şey olmayacaktır, sadece görsel değişiklikler (terminal teması gibi) var gibi düşünebilirsiniz.
💡 İlerleyen kısımlarda asciinema ile alınmış kayıtlar görecekseniz. Video gibi dursa da aslında bu kayıtlar metin yani text tabanlıdır. İzlerken durdurup, izleme ekranından metinleri seçebilir, kopyalayabilirsiniz. Bu kayıtları alırken bir şey olmadığı zaman (kullanıcı girdisi ya da ekrana yazı basılması) kayıt uzamasın diye
asciinema
ya otomatik “jump cut” yaptırtıyorum. O yüzden bazı işlemler olduğundan biraz kısa gözüküyor olabilir. Bundan bağımsız olarak bilgisayarınızın özelliklerine göre (ve internet hızınız) sizde farklı süreler çıkabilir.
İlk olarak kendimize bir çalışma dizini seçelim ve altında git clone
https://git.buildroot.net/buildroot
komutunu çalıştıralım. Eğer minimal bir
kurulum yaptıysanız git
kurulmamış olabilir, bu durumda hata alıyorsanız
öncesinde sudo apt install git
ile git
kurulumu yapınız.
clone işleminin süresi bağlantı hızınıza ve bir miktar bilgisayarınızın gücüne
göre değişecektir. 20-25 Mbps bir internet bağlantısı ve görece zayıf bir
bilgisayarda benim işlemim yaklaşık 1 dakika sürdü. Görebileceğiniz üzere daha
sonra git tag -l --sort=-v:refname
komutu ile git’te verilmiş etiketlere
sıralı bir şekilde bakabiliyoruz. Önceki bölümde her bir sürüm için bir etiket
var demiştik, hatırlıyor musunuz? İşte onlar bunlar.
git clone
ile projenin tüm geçmişini çeksek bile benim diskimde 180 MB yer
kaplıyor ve bu boyut günümüz disk kapasiteleri ve diğer projeler düşünülünce
oldukça düşük kalıyor.
$ du -sh buildroot
180M buildroot
O yüzden git clone
yapabiliyorsanız tar.xz
ile hiç uğraşmayın, git
ile
çekin gitsin. Bundan önceki bölümde de bahsetmiştik.
Buildroot’un çalışabilmesi için derleme yapacağımız sistemde olması gereken zorunlu ve opsyionel yazılımlar vardır. 1
Zorunlu paketler:
which sed make bintuilt build-essential diffutils gcc g++ bash patch gzip bzip2
perl tar cpio unzip rsync file bc findutils wget
araçlardır. Bunlardan
make
versiyonu 3.81’den büyükbuild-essential
sadece Debian tabanlı sistemlerde (Ubuntu ve Linux Mint gibi)gcc
versiyonu 4.8’den büyükg++
versiyonu 4.8’den büyükperl
versiyonu 5.8.7’den büyükfile
ise /usr/bin/file
da olmalıdır (buna neden gerek duyuyor anlamadım).Yine bunlar dışında çeşitli yardımcı araçların çalışması için önerilen araçlar vardır, isimlerini tek tek yazmıyorum burada, Buildroot’un sitesinde varlar. 1
Bootlin firması aşağıdaki komut ile Debian tabanlı sistemlerde doğru geliştirme ortamını sağlayacağımız söylüyor:
sudo apt install sed make binutils gcc g++ bash patch \
gzip bzip2 perl tar cpio python unzip rsync wget libncurses-dev
Burada şöyle bir problem var. Ubuntu’da python
paketini kurmak istediğiniz
zaman bu başarısız oluyor, ya python2
ya da python3
seçmek gerekiyor.
Buildroot’un sayfasında opsiyonel olarak belirtilen Python yazılımının hangi
versiyonunun istendiği yazmıyor. Ama tahmin ediyorum ki Python 2 değildir çünkü
Python 2’ye, 1 Ocak 2020’de “çivi çakılmama” kararı alındı 2 ve yazılımlar
zaten çok daha önceden Python 2’den Python 3’e geçmeye başlamıştı. Bu yüzden
Buildroot’un Python 2’ye bağımlı bir bileşen içerdiğini düşünmüyorum. O yüzden
üstteki komuttaki python
paketini python3
paketi ile değiştirince bende
eksik bir paket olmadığını görüyorum.
python3
düzeltilmiş komut:
sudo apt install sed make binutils gcc g++ bash patch \
gzip bzip2 perl tar cpio python3 unzip rsync wget libncurses-dev
Son olarak yukarıda belirtilen versiyon ve file
programının
konum koşullarını sağlayıp sağlamadığımıza bakalım:
Evet görüldüğü üzere artık hazırız! 🥳
Serinin önceki bölümünde, Buildroot’un kullandığı make
, Kconfig
, Kbuild
gibi
araçlardan bahsetmiştim. Bu konulara tekrar girmeyeceğim.
Konfigürasyon tarafında Buildroot tarafından menuconfig
, nconfig
, xconfig
,
gconfig
araçları destekliyor. Bu 4 aracın da ortak özelliği bizlerin görsel
yani kolay ve doğru şekilde bir derleme konfigürasyonu oluşturmamızı sağlamak.
İşte Buildroot’u bu araçlar ile konfigüre edeceğiz. Bu araçlardan menuconfig
ve nconfig
terminal tabanlı araçlar. Yani konsol içerisinde çalışıyorlar.
Bunlara Text-based User Interface (TUI) tarzı araçlar diyebiliriz. 3
xconfig
QT kütüphanesi, gconfig
ise GTK kütüphanesini kullanan Graphical
User Interface (GUI) araçlardır. 4 Terminal tabanlı olması sebebiyle
pratikliğinden, GUI kütüphaneleri gerektirmemesinden (libncurses-dev
yeterlidir) dolayı SSH gibi bağlantılar üzerinden de sorunsuz çalışabilmesinden
(uzak bir geliştirme bilgisayarına SSH ile bağlısınız ve Buildroot orada
çalışıyor diyelim) dolayı menuconfig
ve nconfig
araçları gözlemlerime göre
daha sık kullanılmaktadır.
Burada ilk olarak git checkout -b bootlin 2022.02
komutu ile 2022.02
versiyonundan (tag) bootlin
isimli bir branch oluşturuyoruz. make help
ile
Buildroot’un desteklediği işlemlere bakıyoruz. make clean
eğer varsa kalmış
ara dosyaların temizlenmesini sağlıyor. Biz zaten ilk defa çalışmaya
başladığımız için bu işlem aslında gerekli değil bu aşamada. make menuconfig
ile, menuconfig
aracını çalıştırıp Buildroot ile beraber gelen Kconfig
dosyalarına göre konfigürasyonu görüyoruz. Burada ok, Enter
, ESC
ve TAB
tuşları ile gezinebiliyoruz. Benzer şekilde make nconfig
ile nconfig
aracını
gösteriyorum. Dikkat ederseniz ikinci make menuconfig
komutu hemen çalışıyor
ama make clean
dersek, make menuconfig
tarafından kullanılan dosyalar da
silineceği için tekrar make menuconfig
dediğim zaman menünün açılması zaman
alıyor.
Şimdi gelin, gconfig
ve xconfig
araçlarına bakalım.
Kayıttan da görebileceğiniz üzere gconfig
ve xconfig
araçlarını hemen
kullanamadık. Önceki bölümde de belirttiğim gibi, gconfig
aracı GTK kütüphanelerine,
xconfig
aracı ise QT kütüphanelerine bağımlı.
gconfig
i çalıştırabilmek için:
sudo apt install libgtk2.0-dev libglib2.0-dev libglade2-dev
xconfig
için:
sudo apt install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools
paketlerini kurmak gerekti. Bu kurulumlardan sonra make gconfig
ve
make xconfig
komutlarını çalıştırabildim. menuconfig
ve nconfig
komutlarının
aksine bu iki konfigürasyon aracının görüntülerini yukarıdaki terminal
kaydında göremiyorsunuz çünkü bu araçlar ayrı bir pencerede açılıyor. Belirttiğim
gibi, GUI araçları. Örnek olması açısından, birer adet görüntüyü ekliyorum.
İlerleyen bölümlerde sadece menuconfig
veya nconfig
kullanacağız.
gconfig
xconfig
Geliştirme ortamımız hazır, ilk derlememizi yapalım.
Burada Bootlin’in, Beaglebone için hazırladığı lab
materyallerini
takip edeceğim (Sayfa 5, Configuring Buildroot
kısmı). Amacımız her
aşamayı anlamak değil, kurduğumuz araçları test etmek olacak. Aşamaları tek tek
buraya yazmıyorum, Bootlin’in dokümanlarından bakarak yapacağım. Aşağıdaki
kayıta ve lab dokümanlarına bakarak siz de kendinizde deneyebilirsiniz.
Bakalım karta yüklenmeye hazır bir şeyler çıkartabilecek miyiz?
Belirttiğim gibi şimdilik sadece “Derleyebiliyor muyuz?” diye baktığımız için seçenekleri Bootlin’in tariflediği gibi yapıp, geçiyorum. İlerleyen bölümlerde detaylara gireceğiz (muhtemelen).
Burada bana ilginç olan, kernel seçeneklerinde OpenSSL ile ilgili bir ayar yapmamız oldu. İlk başta “Acaba Secure Boot gibi bir mekanizma için bir şeylerin imzalanması mı gerekiyor?” diye düşündüm, sonra bu düşünceden uzaklaştım.
Bootlin’in dokümanlarında şöyle bir ifade geçiyor:
The kernel configuration for this platform requires having OpenSSL available on the host machine. To avoid depending on the OpenSSL development files installed by your host machine Linux distribution, Buildroot can build its own version: just enable the Needs host OpenSSL option.
Bunun tam neden olduğunu henüz anlayamasam da platformun kablosuz özelliğinden dolayı olabileceğini düşünüyorum 5. Karşılaştırma yapmak adına, Bootlin’in eğitim için önerdiği ikinci platformun, STM32MP1 Discovery Kit 1, lab dokümanlarına da baktım. Burada da aynı ifade geçiyor fakat bu platfomun da Bluetooth ve Wi-Fi özellikleri var. O yüzden hala bununla ilgili olabileceğini düşünüyorum, ilerleyen zamanlarda burayı kurcalarız.
Bootlin’in dokümanlarında önerdiği şekilde,
make 2>&1 | tee build.log
derlemeyi başlatalım. Burada sadece make
deseniz de yeterli. Önceki bölümde
anlattığım gibi burada tee
komutu, make
in oluşturduğu yazıların, yani logların,
hem ekrana gösterilmesini hem de build.log
isimli bir dosyaya kaydedilmesini
sağlıyor. 2>&1
ifadesi ise make
in stderr
çıkışının da stdout
çıkışına
yönlendirilmesini sağlıyor, ama şu aşamada konumuzun dışında bu kavram.
İlk derleme girişimimizin kaydına bir bakalım:
Loglar akarken şunlar dikkatimi çekti:
Fakat patladık! 🤦
İlk girişimimiz hata ile sonuçlandı, ben dedim demek istemiyorum ama bir
önceki bölümde muhtemelen problemsiz olmayacak demiştim. Dikkat ederseniz
openssl/evp.h
dosyasının bulunamadığı bize söyleniyor. OpenSSL dedim dedim,
başımıza dert açtı. 😅
Normalde bu tarz header dosyaları, ilgili bileşenin “geliştirme paketleri” kurulu değilse sistemde bulunmuyor. Fakat Bootlin’in dokümanlarında şöyle bir açıklama vardı, yukarıda vermiştim:
… To avoid depending on the OpenSSL development files installed by your host machine Linux distribution, Buildroot can build its own version: …
Benim beklentim, benim sistemimde OpenSSL’in geliştirme dosyaları olmasa da
bir problem yaşamamamdı. Yanlış anlamış olabilirim, ama Needs host OpenSSL
seçeneğini açtığımız için benim sistemimde OpenSSL’in geliştirme dosyaları
olmasa da Buildroot’un temin etmesini bekliyordum.
İnternette de tahmin ettiğim şekilde bir çözüm sunulmuş 6: Derleme yaptığımız sisteme OpenSSL’in geliştirme paketini kuralım ve derlemeyi tekrar deneyelim.
Bu sayede hatayı düzeltmiş olduk. Tekrar make
dediğim zaman derleme işlemi
kaldığı yerden devam etti. Bu da make
gibi sistemlerin bizlere sunduğu en
büyük avantajlardan biri: Sadece değişen veya yarım kalan kısımlar derleniyor,
bu da büyük bir zaman avantajı oluşturuyor. Gerçi bizim durumda kernel derlendiği
için zaman avantajını görememiş gibi olduk ama tüm işler bittikten sonra tekrar
make
derseniz aslında hiçbir işlem yapılmadığını görebilirsiniz. Çünkü hiç
bir ayar değiştirmedik, o yüzden var olan bir çıktıyı tekrar oluşturmaya gerek
yok diye düşünüyor make
.
Bu sırada bir hatamı daha düzeltmiş oldum. Bootlin dokümanlarına göre, Kernel
ayarlarına defconfig
olarak omap2plus_defconfig
yazmamız gerekiyordu, ben de
o şekilde yazdım. Fakat loglardan anladığım kadarıyla “birileri” bunun sonuna
otomatik olarak _defconfig
ekliyor ve omap2plus_defconfig_defconfig
oluyor,
bu da hataya sebep oluyor. O yüzden tekrar ayarlara girip, bu sefer
değişiklik olsun diye menu nconfig
kullandım, omap2plus_defconfig
yerine
omap2plus
yazdım ve devam edebildim.
Yukarıdaki paragraftaki hatamı videoyu çekerken fark ettim. Bootlin dokümanları aslında doğruymuş, ben yanlış yazmışım en başta.
Gözlemler:
Needs host OpenSSL
ayarı bir etki gösteriyor bence ama niye header dosyalarını
kurmamız gerekti tam çözemedim. Onu niye temin etmiyor?TI
ve Wireless
kelimeleri geçiyor. BeagleBone Black, bir
Texas Instruments üretimi SoC barındırdığı ve Wi-Fi bağlantısı olduğunu düşününce
bunlar sürpriz değil.Derleme sonrasında çıktılar output/images
altında oluşuyor:
am335x-boneblack-wireless.dtb
: Bizim devicetree’miz.MLO
: U-Boot SPL (Secondary Program Loader)’in adı, config ile biz seçmiştik.rootfs.tar
: RootFS dosya sistemimiz. Yani oluşturduğumuz Linux dağıtımı asılnda
Karta koyacağımız Linux’ta buradaki dosyalar olacak.u-boot.bin
: U-Boot yani bootloaderzImage
: Sıkıştırılmış Linux yani kernel dosyası. Kart ayağa kalkarken
Bootloader tarafından açılıp, RAM’e konulacak.Hatırlarsanız önceki bölümde Buildroot’un derleme süresi ve RootFS dosya boyutu
açısından iddalı olduğunu görmüştük. 2 MB’a kadar düşebildiğini söylüyordu, biz
şu an 31 MB’tayız (rootfs.tar
). Belki ilerleyen bölümlerde bunu küçültmeye
yönelik lablarımız da olur, bilemiyorum. Derleme süresi olarak baktığımızda da
RootFS kısmının (bu durumda Busybox) görece hızlı olduğunu düşünüyorum. En
çok süreyi kernelin derlenmesi aldı.
Bir sonraki bölümde oluşturduğumuz imajı (RootFS + Bootloader + Kernel) karta atıp, deneyeceğiz. Fakat şöyle bir sorun var, ilk bölümde bahsetmiştim:
Bende BeagleBone Black yok, diğer STM32 kiti de yok!
BeagleBone Black temin etmeye çalıştım ama bulamadım. Bende ilk BeagleBone var, beyaz olan ve birkaç farklı model RaspberryPi var. Artık bir sonraki bölüme kadar birini seçip devam edeceğim. Bootlin’in eğitiminde olmayan bir kartı kullanmak daha da öğretici olabilir belki 😇.
Kendinize iyi bakın 🤒 🙋.
]]>İçerik, video olarak sunulmuştur. Bu yazıda (varsa) düzeltmeler ve videoda geçen bağlantılar veya videoya ek notlar sunulmuştur.
Bu video serinin üçüncü videosu. Bu bölümde Buildroot nedir? kimler kullanır? nasıl kullanılır? nereden indirilir? gibi soruların cevabını arıyoruz.
İçerik, video olarak sunulmuştur. Bu yazıda (varsa) düzeltmeler ve videoda geçen bağlantılar veya videoya ek notlar sunulmuştur.
Bahsedilen eklenti: chatgpt-exporter
]]>sudo apt install zsh
Let’s improve its look and functionality via Oh My Zsh
Open BASH:
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
Please install
git
before thecurl
if it is not installed,sudo apt install git
Keep default shell to BASH (my preference for other tools, just in case, like PetaLinux)
Do you want to change your default shell to zsh? [Y/n] n
Now let’s install powerlevel10k.
If you, like me, are not planning to use Unicode in the subsequent steps of
configuring powerlevel10k, you might not need this font. However, I'm not 100%
sure as I haven't conducted a well-controlled experiment.
First install the recommended font: Meslo Nerd Font patched for Powerlevel10k
Link
Download all 4 .ttf
files.
Install fonts locally:
mkdir -p ~/.fonts
cp *.ttf ~/.fonts/
fc-cache
For GNOME terminal, verbatim from powerlevel10k documentation:
GNOME Terminal (the default Ubuntu terminal): Open Terminal → Preferences and click on the selected profile under Profiles. Check Custom font under Text Appearance and select MesloLGS NF Regular.
If you are not able to see that font in preferences, you might need to close all GNOME Terminal instances and relaunch a terminal window.
Then download the theme for Oh My Zsh:
git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ${ZSH_CUSTOM:-$HOME/.oh-my-zsh/custom}/themes/powerlevel10k
Set ZSH_THEME="powerlevel10k/powerlevel10k"
in ~/.zshrc
. The default one
was ZSH_THEME="robbyrussell"
in my case.
Then open zsh
.
When we first open zsh
after installation, we will see powerlevel10k
installation wizard like that:
powerlevel10k installation wizard
You can modify the shell’s appearance to suit your taste, but here are my choices:
diamond y
lock y
upwards arrow y
fit between the crosses y
-
prompt style: 1 lean
character set: 2 ascii
prompt colors: 1 256 colors
Show current time?: 2 24-hour format.
Prompt Height: 1 one line
Prompt Spacing: 1 compact
Prompt Flow: 1 concise
Enable Transient Prompt?: n no
Instant Prompt Mode: 3 off
Apply changes: y yes
Run p10k configure
anytime to reconfigure it.
Now we can use our new theme. Let’s add some plugins!
We can use Oh My Zsh plugins to enrich our shell experience:
My .zshrc
:
ZSH_THEME="powerlevel10k/powerlevel10k"
plugins=(git git-prompt sudo zsh-autosuggestions you-should-use zsh-syntax-highlighting)
My theme and plugins in action:
]]>İçerik, video olarak sunulmuştur. Bu yazıda (varsa) düzeltmeler ve videoda geçen bağlantılar veya videoya ek notlar sunulmuştur.
Bu video serinin ikinci videosu. Burada “gömülü Linux” gibi çok önemli kavramlara değiniyoruz.
RootFS
kavramındaki root
kelimesi ile root
kullanıcısının
bir bağlantısı yoktur. Tipik olarak en tepeden, kök dizinden yani
root noktasından yani, /
noktasından mount edilen dosya sistemine
Root File System, RootFS denir.glibc
gibi bir C
kütüphanesi ile BASH gibi bir uygulama işletim sisteminin userspace
kısmında çalışıyor. Bu videodaki bağlamda hepsinden uygulama olarak bahsetmek
o yüzden sınıflandırma açısından da yanlış değil.İçerik, video olarak sunulmuştur. Bu yazıda (varsa) düzeltmeler ve videoda geçen bağlantılar veya videoya ek notlar sunulmuştur.
Bu video serinin ilk videosu. Burada kendimden ve video serisinden bahsediyorum.
Burada bootlin firmasının Buildroot eğitimini takip edeceğiz.
Size Buildroot öğretmeyeceğim, beraber öğreneceğiz, çünkü ben de bilmiyorum!
Videoda bahsettiğim bağlantılar aşağıda verilmiştir.
Bu yazının konusu, Necati Bey’den ya da Necati Hoca’dan (ki kendisine hoca denmesinden pek hoşlanmıyor hatırladığım kadarıyla ama herkes böyle diyor, ben de böyle diyeceğim yazıda. Kendisi okuyorsa: Kusura bakmayın hocam!) aldığım C dersi olacak. Bu doğrultuda aldığım ders ile ilgili çeşitli bilgiler verip, kişisel görüşlerimi paylaşacağım. Benzer bir kursu Necati Bey ve Kaan Bey’den almayı düşünen arkadaşlara da yardımcı olabilmeyi umuyorum. Uzun bir yazı sizi bekliyor (e dersin kendisi 220 saat, kısa yazmak yakışmaz değil mi!), o yüzden favori içeceğinizi alabilirsiniz, mesela çay 🍵.
Necati Hoca’nın periyodik olarak C ve C++ kurslarını açtığını söylemem yanlış olmaz. Ben de Eylül 2022’de açılan, Online C Kursu’na katıldım. Kurs, 3 Eylül 2022’de başladı ve 2 Nisan 2023’te tamamlandı, neredeyse tam 6 ay. Kurs boyunca toplam 60 ders yapılmış oldu. Ben ise ne yazık ki sadece ilk 9 derse canlı katılabildim. Kalan dersleri kayıtlardan izledim ve bu izlemeyi Kasım 2023’te bitirdikten sonra (dersin başlangıcından itibaren 1 yıldan uzun sürdü), verilen sertifikayı artık hak ettiğimi düşünerek Necati Hoca’dan gururla sertifikamı aldım.
Aldığım Sertifika (QR kod çalışmıyor, boşuna uğraşmayın.)
Başkaları kendine çoğaltırken zorlansın diye rastgele RGB gürültü ekleyecek kadar da düşünceliyim. Evet!
Evet, kurs sonunda bir sertifika alabiliyorsunuz. Gördüğünüz üzere hem Necati Hoca’dan hem de CSD Başkan’ı Kaan Hoca’dan imzalı bir dijital katılım sertifikanız oluyor. Bu sertifika, bir sınav karşılığı verilmiyor, bu bir başarı değil bir katılım sertifikası. Derse katılan herkes sertifikayı alabiliyor. Burada karşılıklı dürüstlük üzerine kurulu bir güven var aslında. Necati Hoca, derslerin hepsini izledikten sonra sertifika istenmesini rica etmişti, ben de öyle yaptığım için sertifikayı almam ve bu yazıyı yazmam Aralık 2023’e kadar uzadı.
❗ Linkedin gibi platformlarda veya iş başvurularında bu ve benzeri kurslarda sertifikası olan arkadaşları görebilirsiniz. Eğer işe alım tarafında çalışıyorsanız CSD sertifikalarının ders tamamlama sonrası verildiğini vurgulamak isterim, yani bir sınav karşılığı verilmiyor, sertifikayı alan kişi tüm derslere (hatta hiç bir derse bile teorik olarak) katılmamış olabilir. Bu sadece bir katılım sertifikası. Ayrıca biri isterse “Paint”te kendisine bunu yapabilir, sertifikanın bir doğrulama mekanizması bulunmuyor. Ama illa emin olmak isterseniz, ilgili adayın aldığı dersin hocasına, adeta kişinin velisi gibi “Bizim oğlanın/kızın dersleri nasıl?” diye sorabilirsiniz belki. Eğer kursun üzerinden çok süre geçmediyse, 200+ saat beraber vakit geçirilen birinin hoca tarafından unutulacağını çok sanmıyorum, hele ki ilgili kişi derse soru/cevaplar ile aktif katılım sağlıyor ise…
Benim aldığım kursun dersleri Cumartesi ve Pazar günleri, 14-18 saatleri arasında, haftada 8 saat olacak şekilde işleniyordu. Kurslar, dersleri ya hafta sonları ya da hafta içi akşam (19-22 gibi) olacak şekilde açılıyor. Kurslar, Zoom üzerinden canlı olarak işleniyor. 4 saatlik dersin toplam yaklaşık 30 dakikası aradan oluşuyor. Canlı ders sırasında, hocaya soru sorabiliyorsunuz. Her kursun bir de Telegram grubu bulunuyor. Yine ders dışında da istediğiniz zaman soru sormak mümkün. Sorularınız genelde yanıtsız kalmıyor. Derslerin video kayıtları Vimeo platformuna yükleniyor ve bir kurs sistemi üzerinden üreteceğiniz şifre ile kayıtlı derslere ulaşabiliyorsunuz. Derslerin kayıtlarına sonsuza kadar erişeceğinizin bir garantisi yok fakat benim aldığım kursun video kayıtlarına 1 sene geçmesine rağmen erişim sağlanabiliyor.
Derste ödevler, daha doğrusu çalışma soruları oluyor. Hoca, bir kısmını derste çözüyor ve bir kısmını kendisine yollamanızı bekliyor. Ben çözüp yollamadığım için oradaki süreci bilmiyorum (tembellikten) fakat gördüğüm kadarıyla gönderen kişilere iyi ve doğru kod yazmayı merkeze koyan bir bakış açısı ile geri dönüşler sağlanıyor. Ama hiç göndermediğim için “şöyle oluyor” desem de yalan olacak. Ders içerisinde de bazen öğrencilerin gönderdiği çözümlerde bulunan genel ve tipik hatalar da konuşulmuştu.
Bizim kursumuz, 180 saat olarak planlanmıştı fakat 220 saat olarak tamamlandı. Araları çıkarttığım zaman da “kemiksiz” olarak 198 saat 10 dakika 02 saniye C işlemiş olduk.
Bu yazı öncesinde beni paylaşımlarından biraz tanıyor olabilirsiniz. Kursa başladığım zaman tam 10 yıllık mühendistim ve gerek mezuniyet öncesi gerekse işe başladıktan sonra profesyonel anlamda C programlama ile zaten bir tecrübem vardı. Kursu alana kadar yazdığım C kodları çalıştığım firmanın ürünlerinde yer alıyordu.
Peki neden bu kursu aldım? Çünkü özünde takıntılı biriyimdir! Üzerine uzun süre zaman harcadığım ve çalıştığım şeylerin incik cincik detayını öğrenmeden pek rahat edemiyorum, bir süre sonra görece “yüzeysel” kalmak batmaya başlıyor. Kendimi gömülü yazılım mühendisi olarak nitelendirmiyorum, bu aralar “Full Stack” Elektronik Mühendisi diyorum başka işler de yaptığım için ama ağırlıklı olarak gömülü alanda yaptığım C programlama ve okuma, günlük rutinimin bir kısmını oluşturuyor. Hal böyle olunca, güzelce ve sakince bir öğrenme ihtiyacı hissettim. Bazı kavramları tam oturtamadığımı hissediyordum. Kursun bu konuda yardımcı olacağını düşündüm (ve yanılmadım). Benim aldığım kursun yaklaşık 1 ay öncesinde başlayan, yine Necati Hoca’nın verdiği C++ kursuna katılan arkadaşlarım vardı. Onların da Necati Hoca hakkındaki olumlu yorumlarını duyduktan sonra kursu almaya karar verdim. Kurs hakkındaki görüşlerimi ilerleyen kısımlarda belirteceğim, burada sadece alma nedenimi belirtmek istedim ama özetle beklentilerimi fazlasıyla karşıladığını söyleyebilirim.
Aslında Kaan Hoca’dan bu kurs öncesinde 120 saatlik bir C kursu da almıştım, kendi kişisel sayfamda ve Linkedin profilimde de bu bilgi var. Fakat bu çalıştığım firmaya verilen kurumsal bir kurstu ve içeriği tam aynı değildi. Necati Hoca’dan aldığım kursu da bu kurs sonrasında aldım. Yani adeta toplamda 340 saat sadece C kursu almış oldum, gerçekten uzun bir süre. İleride buraya tekrar değineceğim.
Başlarda da belirttiğim gibi ne yazık ki canlı katılım imkanım pek olmadı. Canlı katılımın düşmesinin hocanın motivasyonunu da azaltabileceğini biliyorum ama denk getiremedim ne yazık ki (Kusura bakmayın hocam!), çoğunlukla kayıtlardan izledim. Kayıtlardan izlemenin avantajı da yok değil elbette. İstediğiniz hızda izleyip, durdurup geri alabiliyorsunuz. Zorluğu ise disiplini sağlamak. Yani insan salladıkça sallayabiliyor izleme işini. Kendimden pay biçelim, Nisan’da biten kursu Kasım’da tamamlayabildim. Canlı izlemenin bir avantajı da hemen soru sorabilme imkanı. Ama Telegram grubu da olduğu için kayıtlardan izlerken de soru sorma şansı oluyor, tam yerini tutar mı bu size kalmış biraz.
Kurstan elde edindiğim bilgiden aslında kendime bir referans kaynak oluşturmak istedim. Bu yüzden dersleri dinlerken kendime notlar çıkardım. Takdir edersiniz ki videolara süresiz erişim şansı yok ve olsa bile günümüz teknolojisi ile Türkçe içerikli videolarda arama yapmak pek kolay değil. O yüzden yazılı olarak içeriğin elimde olmasını istedim.
Not alma yöntemimi kısaca anlatmak istiyorum, merak edip soran arkadaşlar olmuştu. Notları Markdown formatında aldım. Editör olarak bir miktar eklentiyle beraber Visual Studio Code (VS Code) kullanıyorum. Bu kısımla ilgili belki ayrı bir yazı yazabilirim, o yüzden pek detaya girmiyorum. Daha sonra da Sphinx isimli bir araç ile Markdown dosyaları derleyip, statik bir HTML site oluşturuyorum. Aslında böyle yönetmeye çalıştığım kişisel bir wikimsi bir kaynağım var, ders notları da bunun bir parçası oldu.
Not alma akışım
Sol tarafta görebileceğiniz gibi her ders için aynı bir dosya tutuyorum. Sağ üst köşede, bir adet dosyanın bir kısmını görüyorsunuz. Bu, Markdown formatında bir yazı. Sağ altta ise ilgili dosyanın Sphinx tarafından HTML’e çevrildikten sonraki halinin, tarayıcıda nasıl göründüğü yer alıyor. Ne kadar şeker… 🍬
Herkesin yoğurt yiyişi farklıdır, özellikle not alma konusunda. Ben bu akıştan memnunum.
Derslerdeki içeriği neredeyse olduğu gibi yazıya döktüğüm için bu notlar üzerinden çeşitli sayılar sunmak istiyorum. Böylece dersin ne kadar dolu olduğunu daha rahat aktarabilirim.
Takıntılı biri olduğumu söylemiştim. Takıntılarımdan biri de sanki bir
VT terminalde yazıyormuş gibi bir satırda
80 karakteri aşmamaktadır 2. Yani Markdown dosyalarının bir satırında
(neredeyse) maksimum 80 karakter oluyor. Bir üstteki VS Code ekran görüntüsüne
bakarsanız ekranın en sağında yukarıdan aşağıya inen silik bir çizgi
görebilirsiniz, işte o sütün no 80’i gösteren bir çizgi. İşte bu şekilde
yazdığım zaman, aldığım tüm notların Markdown hali tam 37095 satır tutuyor,
toplamda ise 141784 kelime yazmışım ve bu da 1047310 karakter ediyor
(evet milyon, klavyemin pilinin niye hızlı bittiğine şaşırmamam lazım). Derste
toplam irili ufaklı 1616 adet C kodu yazmışız. Bunlar bir kısmı birkaç
satırlık, bir kısmı ise onlarca satırdan oluşan kodlar. Bu sayı, notlardaki
blok kod sayısını gösteriyor yani Markdown’da ```c <kod>```
şeklinde
yazdığım kodlar. Metin içerisine yazdığım inline olan, Markdown’da ``
olarak yazılan, çok ufak kod parçaları buna dahil değil. Bu 1616 adet C kodunun
toplam uzunluğu ise 12039 satır oluyor. Markdown dosyalarını birleştirip,
pandoc
, xelatex
ve pdftk
araçları ile tek bir PDF’e çevirdiğim zaman ise
690 sayfa uzunluğunda bir doküman elde ediyorum. Bu elbette, font
büyüklüğüne, şablona vs bağlı bir değer. Ama hangi şablon olursa olsun temiz bir
300 sayfa olur diye düşünüyorum. Ders notlarında toplamda 47 adet mülakat
sözcüğü geçiyor, bu sayıdan neden bahsettiğimden ileride bahsedeceğim. Ayrıca
toplamda 200 kere tanımsız davranış
, undefined behivor, UB demişiz. Bu
yine, derste en sık duyacağınız sözcüklerden biri.
Elinizde yazılı notlar olduğu zaman arama yapmak kolaylaşıyor. Not çıkarmak
kolay değil, biliyorum. Hele ki böyle uzun bir kursta not çıkarmak kişiyi
yavaşlattığı için kurs hiç bitmeyecekmiş gibi geliyor. Ama buna dayanıp, not
çıkararak gitmenin faydalı olacağına inanıyorum sizler için de. Komik bir anı
olarak, bizim kurs grubunda bir arkadaşımız struct
lar hangi dersteydi diye
sormuştu. Ben de hiç gerek olmamasına rağmen ders notlarımdaki struct
kelimesinin sıklığını gösteren bir grafik paylaşmıştım. Böyle gereksiz şeyler de
yapmanıza imkan sağlıyor not almak.
Elde notlar olunca böyle veriler çıkarabiliyorsunuz.
Ders notlarıma bakarak kabaca kursu parçalara bölmeye çalıştım. Ben 6 parçaya böldüm. Elbette kurs akıp gidiyor, keskin geçişleri yok ama konu içeriklerine göre böyle bölebilirim diye düşündüm. Kursta işlenen konuları, fikir vermesi açısından paylaşıyorum. Eğer almaya karar verirseniz Necati Hoca’nın kurs ile ilgili Github’taki sayfalarında daha detaylı konu başlıkları da oluyor.
İçerik | Uzunluk |
---|---|
temel C kavramları, temel veri yapıları, fonksiyonlar, operatörler ve öncelikleri, temel kavramlar (short ciruit, UB, sequence point, scope, value category vs.), temel standart kütüphane fonksiyonları, kontrol ve döngü deyimleri, preprocessor (tüm direktifler, functional macro vs.), tür dönüşümleri | 77 saat |
diziler, O() notasyonu, temel algoritma ve veri yapıları, yazı işlemleri | 15 saat |
pointer, pointer aritmetiği, typedef, NULL pointer, string literals, pointer arrays, pointer-to-pointer, void pointer, function pointer (array), multi-dimensional arrays | 51 saat |
dinamik bellek yönetimi, dynamic array, linkage, type qualifiers | 15 saat |
struct, incomplete type, linked list, handle technique, union, enum, bit operations, bitfield | 30 saat |
komut satırı argümanları, dosya işlemleri, C99, variadic functions, VLA, assertions, inline, tipik hatalar | 32 saat |
Toplam | 220 saat |
Siz bu kursu aldığınız zaman süreler biraz değişebilir, bunu fikir versin diye verdim. Necati Bey’in takip ettiği sıra bana başlarda biraz garip gelmişti. Bazı konuların yerlerinin yanlış olduğunu hissetmiştim. Ama ders ilerledikçe konuları, örnek kodlar üzerinden de o kadar güzel bağladığını gördüm ki kursun sonlarına doğru kendisini içimden ve gönülden takdir ettim.
C ve Sistem Programcıları Derneği yani CSD’den bahsetmemek olmaz. Çünkü bahsettiğim kurs aslında hem Kaan Bey ve hem Necati Bey tarafından veriliyor. Sn. Kaan Aslan’nın dernek yöneticiliğini yaptığı (ve bildiğim kadarıyla da kurucusu) olan dernek 1993 yılında kurulmuştur ve İstanbul’dadır. Bugüne kadar C ve C++ olmak üzere çeşitli konularda binlerce öğrenciye ders vermiştir. Ülkemizde bu seviyede ve detayda kurslar verebilen böyle kişilerin ve oluşumların bulunmasını bir şans olarak görüyorum.
CSD, verdiği uzun süreli kurslarla ünlü olan bir dernektir (+ zamanında geliştirdikleri kendi işletim sistemleri de ses getirmiştir). Benim Necati Hoca’dan aldığım C kursu da bu ekolden gelen bir kurstur. Kendisi de uzun yıllar boyunca dernekte eğitmen olarak da görev almıştır. Son yıllarda kursları dernekten bağımsız mı veriyor tam bilmiyorum, ticari ve fatura boyutu da beni ilgilendirmiyor ama derneğin sayfasında kendisi “konuk eğitmen” olarak geçmektedir, ama CSD bünyesinde Kaan Hoca tarafından açılan kurs ile benim aldığım kurs özünde aynı kurstur. Elbette kurslar ve eğitmenler arasında farklılıklar vardır. Objektif bir şekilde belirtebileceğim farkları ilerleyen kısımlarda aktaracağım.
Yeri gelmişken, Kaan Bey’in A’dan Z’ye C Kılavuzu, İntel İşlemcileri Korumalı Mod Yazılım Mimarisi (bu derin teknik bir konudur) ve C Yanlışları adlı zamanında basılmış 3 adet kitabı olduğunu da belirteyim. Bu kitaplar eski ve günümüzde pek bulunmuyorlar (bulan olursa bana da hediye etsin lütfen 😆), sahaflarda olabilir.
Konusu açılmışken belirteyim, A’dan Z’ye C Kılavuzu’na sahip olan arkadaşlar biliyorum (kendi arkadaşlarımda da var). Kaan Bey’in de laf arasında belirttiği gibi bu eski bir kitap ve “modern” C’yi kapsamıyor. Yani bir şekilde bu kitaba erişirseniz buradan C öğrenmek de günümüzde çok doğru bir yol olmayabilir. Kitap yanlış demiyorum ama günümüz için eksik kalacaktır.
CSD demişken şunu da belirtmek isterim: Tam COVID-19 zamanlarında, CSD kurs notlarını kendi Github sayfalarından “fırsat eşitliğine katkıda bulunmak” için paylaşmıştır.
Salgın zamanı ilaç gibi hareket 💉
Kısaca kral hareket demek istiyorum! Notların önemli bir kısmı Kaan Bey’e aittir ve bu şekilde paylaşmaları takdir edilesidir 👏. Notlar, Türkçe olarak (hatta belki İngilizce kaynaklar arasında da) bulunabilecek en kaliteli ve doğru kaynaklardandır. Linki bıraktım.
Kimlere uygun değil?
C kursu, muhtemelen CSD’nin kurulduğu 1993 tarihinden itibaren verilen bir kurs. Wayback Machine üzerinde CSD’nin en eski arşivi 1999 yılından çıkıyor ve bu yılda da bu kurs veriliyormuş.
😂 Fun fact: CSD’nin sitesine gideceğim diye kafadan http://csd.org.tr yazarsanız sizi Çorap Sanayicileri Derneği karşılıyor. Derneğin websitesi https://csystem.org/ tur.
Ben de ne yaptım dersiniz? Kursun süre ve fiyat geçmişini de merak ettiğim için aşağıdaki tabloyu oluşturdum. Fiyatı doğrudan TL olarak vermemin pek anlamlı olmayacağını düşünerek (2005’te 6 sıfır atma da var), asgari ücret ve USD cinsinden kurs fiyatının değişimini göstermek istedim. Fiyatları yine Wayback Machine üzerinden elde ettim. Elbette ilgili yılın asgari ücret ve kur bilgilerini kullandım.
Yıl | Kurs Süresi (Saat) | x Asgari Ücret | USD |
---|---|---|---|
1999 | 120 | 3.05 | 405 |
2002 | 135 | 3.25 | 364 |
2006 | 150 + 30 (C Std) | 3.75 | 1065 |
2010 | 160 + 30 (C Std) | 2.81 | 1078 |
2015 | 160 + 30 (C Std) | 2.67 | 966 |
2020 | 170 | ? | ? |
2023 | 200 | 1.1 | 480 |
Necati Bey’in Ocak 2024’te başlayacak kursunun belirlenmiş fiyatı 18000 TL. Henüz o gün gelmediği ve kur bilgisi gibi bilgiler elimde olmadığı için tabloya eklemedim.
Kurs fiyatının zamanla değişimine bakarsanız yeni fiyatlar ucuz da gelebilir, pahalı da. Elbette son yıllarda kurslar online olarak verildiği için katılımcı sayısı muhtemelen çok daha fazla eskiye göre. Benim gözlemlediğim kadarıyla CSD ve Necati Bey’in kurslarına en az 100 kişi kayıt oluyor. Bu yüzden “sürümden kazanacak” şekilde kurs fiyatları USD cinsinden eskiye nazaran düşürülmüş olabilir. Bir de KDV ve öğrenci/”tam” konusu var. Artık o detaylara kursu almak isterseniz siz bakarsınız. Onun dışında fiyatın pahalı olduğunu da düşünebilirsiniz, Udemy’nin fiyatlarına bakarsanız haksızsınız diyemem ama kurs içeriği vs. bir sürü parametre var. Özellikle bireysel katılım için az bir para değil elbette. Bu konuyu bir sonraki başlık altında biraz daha irdeleyeceğim.
Bir de dikkat ederseniz kurs zamanla uzamış, güncel durumda 200 saat açılıyor umarım daha da uzamaz. Bir ara 30 saatlik “C standardı” kursu ayrı veriliyormuş gördüğüm kadarıyla. Burada C99 standartları ayrıca anlatılıyor diye anlıyorum. Zamanında bu 30 saatlik kursun saatlik fiyatı 150 ya da 160 saatlik ana kursun saatlik fiyatının birkaç katıymış. Aslında bu 30 saatlik kursu eklemezseniz tablodaki toplam fiyatlar fena olmayan bir oranda düşüyor ama günümüzdeki kurslarda bu konular kursa dahil edilip tek kurs olarak anlatıldığı için eklemeyi uygun gördüm.
C dilinin en büyük değişimi C99 ile yaşadığını söylemek herhalde yanlış olmaz. Kulağa biraz garip gelebilir ama ilerleyen yıllardaki standartlarla eklenen ve günümüzde yaygın olarak kullanılan çok sayıda özellik var diyemeyiz. Yani dil o kadar da büyümez iken ders niye sürekli uzuyor bilmiyorum. Belki eğitmenler daha çok soru çözüyordur, sınıf kalabalıklaşınca eğitmene gelen soru sayısı artıyordur ve akış yavaşlıyordur artık onu bilemiyorum ama 200 saat’i geçmez umarım, biraz psikolojik bir sınır bence.
Kişisel siteme veya Linkedin profilime bakarsanız bu kurstan önce PLC2 ve Doulos gibi kurumsal eğitim firmalarından çeşitli konularda kurslar aldığımı görebilirsiniz. Biraz bu tarz kursları da göz önünde bulundurarak bir kıyaslama yapmak istiyorum.
Bildiğim kadarıyla bahsettiğim firmalardaki kursların en uzunları 40 saat oluyor. Örnek olarak gelin Doulos tarafından verilen C Programming for Embedded Systems isimli kursa bir bakalım.
Bu kursu ben almadım fakat alan arkadaşlarım oldu. Bu yazıyı yazmadan önce Doulos’un kursunun da notlarına göz attım. Doulos, alanında oldukça iyi bir eğitim firması. Notlarda gözüme büyük hatalar çarpmadı (ufak tefek var). Fakat C ile ilgili bazı konular çok hızlı geçilmiş bence. Elbette iki kursun amacı farklı. Doulos’un kursu gömülü sistemlerde C programlamayı hedefliyor. Bu kurs, 4 günlük ve 8 saat/gün olarak düşünürsek kursun toplam süresi yaklaşık 32 saat olacaktır. Kurs sayfasında da belirtildiği üzere kursun yarısı eğitimden yarısı ise lab alıştırmalarından oluşuyor. Kursa fiziksel katıldığınızda (online katılımda nasıl yapılıyor bilmiyorum) bir demo kart üzerinde de çalışıyorsunuz.Bu kursların fiyatları ise kur ile değişmek ile beraber Necati Bey tarafından Ocak 2024’te açılacak 200 saatlik C kursunun iyimser bir tahminle en az 2-3 katı.
Necati ve Kaan Bey kadar dile bu kadar hakim birilerine denk gelmeniz de pek olası değil. Eğer bir iş veren olsaydım ve çalışanlarıma 200 saatlik C kursunu aldırsaydım bunu ekonomik bulurdum. Bu kursu hakkını vererek tamamlayan bir çalışan zaten daha az hatalı kod yazarak, daha hızlı kod yazarak kendi kurs parasını rahatlıkla çıkaracaktır. Buradaki esas problem zaman. 200 saat gerçekten uzun bir süre. Bir de not tutuyorsanız, ödevleri çözüyorsanız ve ek çalışma yapıyorsanız belki bir 200 saat daha harcarsınız. Kursların mesai saatleri dışında olduğunu belirtmiştim. Yine bir iş veren olsam ve çalışanım bu kursu mesai saatleri dışında alacağım dese ona hem kursu aldırır hem de bir kurs parasını da ona teşvik olarak verirdim belki 😬. Kurumsal bakış açısıyla fiyatın, diğer eğitim firmalarının eğitimlerini de düşünerek çok sürpriz olmadığını söyleyebilirim.
Gelelim bireysel katılımcılara. Eğer bir çalışansanız ve kendi cebinizden alacaksanız (benim gibi) da hala alınabilir diye düşünüyorum. Profesyonel yaşantıda para kazandığınız şeye yatırım yapmanız gerekiyor. Bu bir yazılım olabilir, donanım olabilir ya da kendiniz olabilirsiniz. Bu yatırımlar her zaman ya da hemen paraya dönüşmeyebilir. Ama bu işten para kazanıyorsanız ve uzun yıllar çalışmayı düşünüyorsanız kursu kendinize yatırım olarak düşünülebilir. Bu kursun bir iş ya da terfi garantisi elbette yok ama böyle bir duruma yardımcı olursa zaten parasını çıkaracaktır.
Öğrenci arkadaşlarımız için kursta bir miktar indirim oluyor ama kurs hala muhtemelen pahalı kalacaktır. Bu ve katıldığım başka kurslarda üniversite, lise öğrencileri ile hatta daha küçük kardeşlerimizle karşılaştım. Lisede okuyup, CSD’den üçüncü kursunu alan bir arkadaşımızı hatırlıyorum. Açıkça bu vizyon ve azimlerini takdir ettiğimi söylemek isterim. Bizim zamanımızda online kurslar yoktu böyle ama hani şimdi okuyor olsam yine bunu almayı akıl eder miydim bilmiyorum. Bu arkadaşların kendilerine çok iyi bir yatırım yaptıklarını söyleyebilirim. Ama buna heves edip maddi durumu yetmeyen arkadaşların üzülmemesi gerekiyor. Öğrenci iken ailenizin imkanı olmayabilir bu paraları vermeye. Kariyer çok uzun bir yol, bu kursu ya da eksiklerinizi para kazanmaya başladıktan bir süre sonra hevesiniz var ise yine tamamlayabilirsiniz, çok da üzülecek bir durum yok bence. Eldeki imkanlara göre kendimize bir yol çizmemiz gerekiyor, kendimizi fazla üzmeden ve yıpratmadan… Yani alabiliyorsanız çok iyi ama alamıyorsanız da üzülecek bir şey yok, belki işe girdiğiniz firma bile size bu eğitimi aldırtabilir. 😉
Çevremde CSD kursları konuşulduğunda hemen Udemy kursları ile bir kıyaslama yapılıyor. Udemy kursları hem çok daha ucuz ve kısa. Bazı firmaların Udemy Businness anlaşmaları da olduğu için mümkünse tüm eğitim ihtiyaçlarını bu platformdan karşılamak istiyorlar. Takdir edersiniz ki Udemy’deki tüm kursları izleyip bir kıyaslama yapmam mümkün değil. Özellikle C ile ilgili de birçok kurs var. Dildeki önemli detaylar ne kadar doğru anlatılıyor inanın bilmiyorum. Udemy’deki problem eğitmenin kalitesi ile ilgili pek bir bilginiz olmaması. Bir kursa verilen puanlar gerçeği çok iyi yansıtmayabiliyor çünkü puanları kursu alan ve öğrenen kişiler veriyor. Siz bir kursta öğrencileri çok zorlamayarak ve bilmediklerini pek hissettirmeyerek öğrencilerin kursa pozitif duygular beslemesini ve yüksek puan vermesini sağlayabilirsiniz. Ayrıca öğrenen kişi en fazla dersin işleniş tarzını puanlayabiliyor, zaten öğrendiği bir konunun doğruluğunu bilmesi pek olası değil. O yüzden Udemy (veya benzer platformdaki) kursları düşünürken bu şekilde düşünmek gerekiyor.
Hem Necati Bey hem de Kaan Bey kurumların talebi üzerine doğrudan kuruma özel sınıf açıp, ders veriyorlar. Peki hangisini tercih etmeli?
⚠ İlerleyen paragraflarda yazılanlar bu kurs veya bu eğitmenler hakkında değil, genel olarak kurumsal eğitimler hakkındaki görüşlerimdir.
Bugüne kadar yurt içi/dışı çeşitli eğitim kurumlarının çeşitli derslerinin kurumsal olarak (özel sınıf) düzenlenmesinde görev aldım. En son söyleyeceğimi en başta söyleyeyim:
Herhangi bir kurumsal eğitimde en az 1 kişi mutsuz olur ve o kişi de eğitimi organize edendir!
Eğer bir kurumsal eğitim organize etmeye çalışan bir mühendisseniz, elinizdeki “Eğitim Talep Formu”nu hemen yere bırakın ve alabiliyorsanız genele açılan kursları alın 😄. Eğitimi organize etmeye çalışan kişi çoğunlukla eğitmen, eğitime katılan iş arkadaşları (sınıf), yöneticiler ve varsa kurumunda eğitimler ile ilgilenen bölüm ve parayı ödeyen satın alma bölümü arasında sıkışabiliyor. Bu sıkışıklıkta en azından düzenleyen kişi bir mutsuzluk, bir “lanet olsun” hissi yaşayabiliyor. Çoğu zaman da ya sınıftan en az biri ya da eğitmen mutsuz oluyor. Fakat yine de herhangi bir kurumsal eğitim alacaksanız, eğitim öncesinde şu noktalara dikkat etmenizi öneririm:
Bu yukarıda saydığım maddeler herhangi bir kurumsal kurs düzenlerken dikkat etmeniz gerekenler. Bu konularda eğitim aldığınız kurum ile yazılı olarak (e-posta gibi) anlaşmalısınız, hatta olabiliyorsa mini bir sözleşme de yapabilirsiniz.
Bu C kursuna ve benzeri kurslara bakacak olursak genel sınıf kursuna katılımın çeşitli avantaj ve dezavantajları olabilir.
Tahmin edersiniz ki özel kursun ekonomik anlamda mantıklı olması için kursu kalabalık bir grup olarak almanız gerekecektir. Zaten 2-3 kişi alacaksanız genele açılan kurslar dışında bir şansınız yok.
Genel derslerin işlendiği saatler, konu, süreler ve tempo sizler için uygun değilse özel kurs talebinde bulunabilirsiniz.
Kurumsal eğitim düzenleme işinden biraz ağızım yandığı için biraz karamsar ve taraflı bir tablo çizmiş olabilirim. Belirttiğim gibi yazdıklarım C kursu veya bahsettiğim eğitmenler özelinde değil, genel önerilerdir. Birçok kurumsal kurs firması zaten “halka açık” kurslar düzenlemiyor, o noktada tercih şansınız olmuyor zaten isteseniz de istemeseniz de kurumsal olarak kursu almanız gerekiyor.
C’yi kullanan veya öğrenmek isteyen kitlenin önemli bir kısmı gömülü sistemler alanında çalışıyor. Peki bu dersin içeriği bu tarz işlerde çalışan kişilere uygun mu? Genelde Gömülü C ile ilgili bir konu açıldığında her ne kadar çoğu insan da yanlış bir algı olmasa da öncelikle şunu vurgulama ihtiyacı hissediyorum: C dili Gömülü C ve Normal C olarak ikiye ayrılmıyor.
Yani Gömülü C diye ayrı bir dil yok, öncelikle bunu vurgulamakta fayda var. Ha elbette gömülü sistemler için yazılmış C kodları ile örneğin bir Linux işletim sistemi üzerinde çalışacak şekilde yazılmış C kodları arasında belli başlı farklar olabiliyor. Bir programlama dilini bize çeşitli araçlar sunan bir araç kutusu olarak düşünebiliriz. C dili de bundan farklı değil. Programcı olarak kullanabileceğimiz bir çok araç seti yer alıyor. Belki gömülü sistemler için söyleyebileceğimiz şey, bazı araçların daha sık bazı araçların ise daha az kullanılması olabilir. Ama kullandığımız dil bir adet: C.
Konu ile ilgili güzel bir LinkedIn postu
Örneğin gömülü sistemler için yazılmış bir C kodunda, doğrudan bellekte belirli
bir adresi gösteren pointerları, struct
ve union
gibi anahtar kelimeleri,
bit işlemlerini, function pointer kullanımını bir tık daha sık görebiliriz. Buna
karşılık birçok gömülü sistemde dinamik bellek kullanımı tavsiye edilmediği ya
da desteklenmediği için malloc()/free()
türevi fonksiyon çağrılarını da daha
az görebiliriz. Yine gömülü sistemlerde bellek limitinden dolayı bellek alanının
(stack ve global alan) verimli kullanımı için bazı teknikler kullanılıyor
olabilir. Ama bu tekniklere Linux üzerinde koşacak “sistem programları”nda da
rastlamak mümkün. Benim tavsiyem, gömülü sistemlerde çalışıyor olsanız da C
dilinin genelini bir öğrenin, dildeki araçları ve dilin sınırlarını görün.
Elbette zamanla bazı kısımlarını daha sık bazı kısımlarını da daha seyrek
kullanacaksınız.
Gömülü sistemlerde C diline hakimiyet önemli bir artı olsa da bu tek başına genelde yeterli değil. Buna ek olarak, temel bir elektronik bilgisi, I2C/SPI/UART gibi temel iletişim protokolleri hakkında bilgi, bir osiloskop ile kart üzerinden ölçüm alabilme, bilgisayar mimarileri ve işlemciler hakkında bilgi, bir miktar assembly bilgisi aranan yetkinlikler arasında yer alıyor. Bu yüzden iyi bir C bilgisi çok işinize yarayacaktır ama diğer konularda da kendinizi geliştirmeniz beklenecektir.
Derse gelecek olursak, gömülü sistemlerde sık kullanılan araçlar olmak üzere dilin tüm araçları anlatıldığı için bu açıdan bir eksiğiniz kalmayacaktır. Ayrıca Necati Bey dersin birçok noktasında yazdığı kodlar üzerinden bir kodun daha verimli (hız veya bellek alanı gibi) nasıl yazılabileceğini defalarca anlatmaktadır. Ben de C’yi ağırlıklı gömülü tarafta kullanan biri olarak verilen örneklerden oldukça tatmin oldum. Ama dediğim gibi gömülü yazılım işi sadece C’den ibaret değil, fakat önemli bir kısmı da C hakimiyeti.
Çeşitli kurumlarda (verdiğim Doulos kursu örneği gibi) ve internette C’yi mikrokontrolcü gibi bir gömülü sistem üzerinden anlatan kurslar bulmak mümkün. Bu böyle bir kurs değil, onu da belirtmiş olayım.
Okulda aldığınız C dersini geçmek için bu kursu almanıza hiç gerek yok. Kurs zaten uzun sürdüğü için okuldaki C dersinizden belki 1 dönem önce buna başlamanız gerekecektir. Zaten okulda aldığınız C dersinde hocanızın ve asistanların C’yi muhtemelen pek de iyi bilmediğini göreceksiniz. Bu kurs, profesyonel anlamda C ile uğraşan ya da uğraşacak kişiler için uygun. Okuldaki C için YouTube dersleri ve Udemy fazlasıyla yeterli olacaktır. Öğrenci iseniz almayın demiyorum, zaten yukarıda bahsettim bu konudan ama sırf ders geçmek için almayın. Böyle alırsanız tam bir overengineering yapmış olursunuz. Ama diyelim ki aldınız, okulda size muhtemelen C’yi az ya da çok yanlış öğretecekleri için sinirleriniz bile bozulabilir derste, benden söylemesi…
Fakat elektronik ya da bilgisayar mühendisliği gibi bir alanda okuyorsanız ve meslek hayatınızda C’nin yer alacağını düşünüyorsanız ve amacınız sadece okuldaki C kursunu geçmek değilse, bu kursu öğrenci iken alabiliyorsanız (para ve zaman) açısından muhakkak alın, kendinize çok iyi bir yatırım yapmış olacaksınız.
Mülakatlara hazırlık konusunda Necati Bey’den C öğrenmenin doğru bir karar
olacağını rahatlıkla söyleyebilirim. Hatırlarsanız yazının başında kendi
notlarımdan çeşitli sayıları sizlerle paylaşmış ve notlarımda toplam 47 kere
mülakat
kelimesinin geçtiğini belirtmiştim. Bunun sebebi derste mülakatlarda
sık çıkan soruların da çözülmesidir.
Yine belirttiğim gibi Necati Bey, recruiter olarak da görev alıyor. Kendisi C/C++ bilen geliştirici arayan firmalar için uygun adayları eşleştirmek adına kişilerle mülakat yapıyor. Sürekli mülakatların iş veren tarafında olan biri olarak derste C mülakatlarında sorulan sorulardan da bahsediyor. Bununla ilgili ilginç bir durumu da aktarmak istiyorum.
Apple’da 🍏 gömülü sistemler üzerine C ağırlıklı çalışan bir arkadaşımla konuşurken, işe girerken ona sorulan mülakat sorularından bahsetmişti. Bu konuşmamız kurstan önceydi. Kursun sonuna geldiğimizde Necati Hoca bu soruların neredeyse hepsini çözmüştü. Soruları derste görünce şaşırmıştım. Elbette Apple’ın ya da bir firmanın sorduğu C mülakat soruları üç aşağı beş yukarı aynı olmaktadır, sonuçta adayda test edilmek istenen bilgiler ve soru tarzları belli. Bu yüzden firmalar benzer soruları soracaktır.
Bu kursun C’yi ilk defa öğrenmek isteyen kişiler için uygun olacağını düşünüyorum. Bu konuyu kendim deneyimlemediğim için kesin konuşamıyorum. Belirttiğim gibi ben kursu almaya başladığımda 10 yıllık mühendistim. Bu yüzden hiç C’yi bilmeyip bu kursu alan kişinin ne hissettiğini bilemem. Ama kursun içeriğinden, gidiş hızından, kursu bu şekilde alan arkadaşlara ait gözlemlerimden, kursun yeni başlayanlar için de uygun olduğunu söyleyebilirim.
Hatta Necati Hoca, sık sık en sevdiği öğrenci profilinin C’yi bilmeyen kişiler olduğunu belirtmektedir. Buna hak veriyorum, çünkü C’yi okuldan veya başka yerlerden öğrenen kişilerin önemli bir kısmı özellikle pointer, array gibi konularda hatalı bilgiler ile geliyor. Necati Hoca, derste sık sık önce bu hataları düzeltmeye çalışıyordu. Bizlere sürekli unlearn (yani unutulması) edilmesi gereken kısımların olduğunu belirtiyordu.
Eğer programlama ile ilgili hiçbir fikriniz yok ise, bir programlamaya giriş kursunun alınması belki faydalı olabilir. Bu doğrultuda CSD’de 80 saat olarak Ali Vefa Serçe Bey tarafından verilen Programlamaya Giriş kursunun iyi olabileceğini duydum, kendim deneyimlemedim, çevremde de alan bilmiyorum. Böyle bir durumdaysanız bir kontrol edebilirsiniz.
“Uzun C kursu”, CSD bünyesinde hem Kaan Bey hem de Necati Bey tarafından farklı zamanlarda verilebiliyor. Burada da Kursu kimden almalıyım? gibi bir soru akıllarda oluşuyor. En son söyleyeceğimi en başta söyleyeyim:
İstediğiniz hocadan alabilirsiniz. İki eğitmen de size C’yi düzgün bir şekilde öğretecektir.
Hoca ve ders karşılaştırması yapmak gerçekten çok öznel bir şey. Hiç unutmuyorum, üniversite yıllarında aynı sınıfta aynı hocadan aynı dersi aldığımız bir arkadaşım ile konuşuyorduk. Ben hocanın ve işleyişinin çok iyi olduğunu söyleyince o da hiç bir şey anlamadığını, hocanın çok kötü anlattığını söylemişti. Aynı dersi veren başka bir hocadan dersi takip ettiğini ve onun sayesinde anlayabildiğini iletmişti. Sizin de tecrübe etmiş olmanız çok olası, her hoca ve her anlatış tarzı herkese gitmiyor. O yüzden benim burada kendi görüşlerimi aktarmam sizlere faydalı olmayacaktır. Ama nesnel olduğunu düşündüklerimi aktaracağım.
İki hocayı karşılaştırmamda teknik olarak da şöyle bir problem var: İkisinden de aynı dersi almadım. Yazının başında Kaan Bey’den bir kurum eğitimi çerçevisinde 120 saatlik C eğitimi aldığımı belirtmiştim. Bu, dışarıya açık olan bir kurs değildi ve içeriği farklıydı. Necati Bey’den aldığım kurs ise dışarıya açık olan bir kurstu. İki eğitmenden birebir aynı dersi almadığım için teknik olarak doğru bir karşılaştırma yapmam zaten mümkün değil.
Yine de Kaan Bey’in genele açılan ve aldığım kurslardan edindiğim gözlemlerle olabildiğince objektif noktalara değinmeye çalışacağım.
Kurs ile ilgili hissedebileceğiniz çeşitli olumsuzluklardan biraz bahsetmek istiyorum.
.txt
formatında bir kurs notu
elinizde oluyor. Necati Bey’in kursu sonunda ise elinizde sadece videolar
oluyor. Hoş Udemy kursları da genelde sadece video içerikli oluyor. Kaan
Bey’in notları oldukça yeterli. Ama özellikle Necati Bey’in kursu sonrasında
bir ders notu olmaması kurumsal tarafta çeşitli soru işaretleri doğurabiliyor
(gözlem).Kursu almaya düşünen arkadaşlara naçizane önerilerim şöyle olacaktır:
C ve C++ ile çalışıyorsanız Necati Bey’in kurucusu olduğu Türkiye C++ Topluluğu‘na muhakkak katılın. Necati Bey gibi alanında bilgili kişilerin olduğu iki adet Telegram grubunda (C++ Türkiye - Basic ve C++ Türkiye Topluluğu) kaliteli bilgi paylaşımları ve tartışmalar dönüyor. C ile ilgili sorularınızı Basic grubuna sorabilirsiniz. Grupların adresleri topluluğun sitesinde bulunuyor. Topluluğun bir de bir YouTube kanalı var. Zaman zaman canlı yayınlar ve çeşitli sunumlar yapılıyor.
Necati Ergin: GitHub, YouTube ve LinkedIn, Kaan Aslan: LinkedIn, CSD: LinkedIn takip edebilirsiniz.
Necati Bey, yakın zamanda Coşkun Taşdemir Bey’in canlı yayınına konuk olmuştu:
Yıllar önce Bilişim Sohbetleri kanalı tarafından, CSD ile yapılmış uzun bir program (ses kalitesi biraz kötü):
Buraya kadar okuduysanız tebrik ve teşekkür ederim. Amacım kursu almayı düşünen arkadaşlara faydalı olabilmekti, umarım öyle de olabilmişimdir.
Görüşmek üzere… 👋
]]>Not: Bu okuduğunuz yazı, derste aldığım notlardaki gibi bir satırı 80 karakter ile limitleyince Markdown formatında 820 satır tutuyor. 60 derste tuttuğum notların ortalaması 618 satır ediyor. Bu da böyle bir istatistik…
Xilinx’in Remote Debugging başlığı altında sunduğu iki adet çözüm var: Bunlardan ilki (bu yazıda üzerine konuşacağımız), karta fiziksel bir JTAG bağlantısı içeriyor. Fakat bu çözümde alışkın olduğumuz kurgunun aksine bir değil, iki adet bilgisayar var ve bu bilgisayarlar ağ üzerinden bağlı, detaylara geleceğiz. Diğer çözüm ise, karta fiziksel bir JTAG bağlantısı istemeyen, adeta karta doğrudan yapılan bir Ethernet bağlantısı üzerinden “sanal bir JTAG” bağlantısı oluşturulan Xilinx Virtual Cable (XVC) çözümü. Bu yazıda XVC’ye değinmeyeceğim.
Gelin aşağıdaki duruma bir bakalım:
Yukarıdaki yapıda ağ üzerinden “bir şekilde” bağlı iki adet bilgisayar görüyoruz. Bu bilgisayarların bir tanesine Platform Cable (demo kartlar üzerindeki dahili JTAG gibi benzer bir donanım olabilir) ile kartın JTAG arayüzü bağlı. Bu bağlantıda kartın bağlı olduğu bilgisayara lab bilgisayarı, diğerine ise geliştirme bilgisayarı diyeceğiz.
İlk bakışta bu bağlantı çok da mantıklı gelmiyor değil mi?
Tek bir bilgisayar üzerinden bunu yapabilirken niye iki adet bilgisayar kullanalım?
Evet, haklısınız. Çoğu durum için tek bilgisayar yeterli. Ama iki bilgisayarlı setup’ın da kullanışlı olduğu durumlar var, gelin bir bakalım.
Vivado ve Vitis’in yeni sürümleri çıktıkça ve entegreler de büyüdükçe bu yazılımların talep ettiği disk ve RAM boyutları hızla artıyor. Örneğin AMD Vitis 2023.2, 64 GB RAM öneriyor. Elbette tüm Vitis projeleri için bu kadar belleğe ihtiyaç yok ama basit projelerde bile 8-16 GB belleğin yetersiz kalabildiğini hemen görebiliyorsunuz. Bazı mühendisler, çalıştıkları kartı bilgisayarlarının yanında tutabilecek kadar şanslı ama birçok mühendis de bir sistem üzerindeki bir kartta çalışmak durumunda kalıyor. Örneğin bir sisteme entegre edilmiş bir kart, masanızdan veya labınızdan uzak bir yerde oluyor ve o sistemin yanına bir laptop ile gitmek gerekiyor. Görece güçlü laptoplar, masaüstü sistemler kadar yaygın değil. Bir seçenek Vitis’i doğrudan çalıştırabilecek güçlü laptoplar almak (maliyet açısından uygun olmayabilir, ağır olabilir, başkasının bilgisayarında çalışmanız gerekiyor olabilir). Diğer bir seçenek de basit bir laptop alıp, bunu hedef karta sadece JTAG bağlantısını almak için takmak ve ağ üzerinden daha güçlü bir bilgisayara bu JTAG bağlantısını Xilinx’in sağladığı Remote Debugging altyapısı ile açmak. Bu sayede uzaktaki güçlü masaüstü bilgisayar sanki USB’den Platform Cable takılıymış gibi kart üzerindeki entegreye erişebilecektir.
Senaryomuzu biraz değiştirelim ve aşağıdaki duruma bakalım. Bu çizim üzerinden birden fazla olası durumu anlatacağım.
Diyelim ki sağda solda duran kartlarla uğraşmamıza gerek yok, masamızda çalışabiliyoruz. Eğer 10 kişilik bir takımsak herkese güçlü masaüstü bilgisayarlar almamız gerekecektir. Bunun yerine, uzaktan bağlantı ile (Windows Remote Desktop, VNC, X2Go vs.) geliştirme yapacağımız güçlü, workstation veya sunucu sınıfında bilgisayarlar kullanabilir, 10 adet giriş seviyesi masaüstü veya laptop bilgisayarı takıma dağıtabiliriz. Herkese güçlü bilgisayarlar verseydik, 10 x 64 GB = 640 GB’lık bir hafıza maliyetimiz olacaktı. Elbette uzaktaki ortak geliştirme bilgisayarının biraz güçlü olması gerekiyor, özellikle aynı anda birden fazla kişi çalışacaksa. Ama burada tepe kullanıma göre değil de ortalamaya göre bir kaynak ataması yapacak olursak, örneğin 256 GB’lık bir makina muhtemelen iş görecektir ve takıma da 16 GB’lık makinalar dağıtırsak 256 + 10 x 16 = 416 GB ile işi hallettik, takımdaki bilgisayarlar adeta bir thin client oldu.
💲 Fun fact: Tepe kullanıma göre değil, istatistiksel bir kullanıma göre yatırım yaptığımız için adeta bulut bilişim sağlayıcıları (cloud provider) ve Internet servis sağlayıcıları (ISP) gibi “para kazandık.”
Vitis’in yanında PetaLinux ve Yocto gibi araçlar kullanıyor olabilirsiniz. Bu araçlar zaten Linux dağıtımları üzerinde çalışmaktadır. Üstteki senaryodan devam edecek olursak, takımın masasındaki bilgisayarlar Windows olabilir. Linux bir ortamda Windows üzerinde çalışmak için WSL ya da sanallaştırma gibi çözümler var. Fakat PetaLinux ve Yocto’nun görece güçlü geliştirme ve derleme ortamları istediğini düşünürsek yine uzaktan erişilebilen güçlü bir Linux bilgisayar mantıklı duruyor. Remote Debugging, farklı işletim sistemleri arasında da yapılabiliyor. Yani lab bilgisayarı ve geliştirme bilgisayarı dediğimiz bilgisayar Windows veya Linux olabilir biraz üstteki çizimde gösterdiğim gibi, 4 kombinasyon da mümkün.
Çalışılan proje sayısı arttıkça bilgisayarda birden fazla Vitis veya Vivado bulundurmak gerekiyor. Fakat ne yazık ki bu yazılımların istediği disk alanları az değil. Örneğin Vitis 2023.2, en az 200 GB’lık bir disk alanı istiyor. Sadece kurduğumuz programların kapladığı alanın, yaptığımız proje sayısı arttıkça terabyte mertebesine ulaşması çok zor değil. Onun yerine yine uzaktan erişilebilen ve kullanılan tüm araçların kurulu olduğu güçlü geliştirme bilgisayarları kullanılabilir. Bu durumda kendi bilgisayarımıza sadece Vivado Lab Solutions kurmamız yeterli oluyor. Bunun Vivado’nun sadece Hardware Manager’i içeren bir hali olarak düşünebiliriz. Örneğin Vivado Lab Solutions 2022.1’in kurulmuş hali diskte sadece 6.1 GB yer kaplıyor. Böyle kısıtlı iş yapan bir yazılım için bence hala büyük ama Vivado’nun kendisine kıyasla oldukça az. Eğer uzaktan erişebileceğimiz güçlü bir bilgisayarımız var ise buna Vivado’ları kurabilir, kartı takacağımız bilgisayarlara ise sadece Lab Solutions’ları kurup ciddi bir disk tasarrufu elde edebiliriz.
💡 Eğer birden fazla Vivado/Vitis versiyonu ile çalışıyorsanız her birinin ayrı Lab Solutions uygulamasını kurmanızı öneririm. Görece az yer kaplayan bu uygulamalar için disk cimriliği yapıp, tasarruf yapmaya bence çalışmayın. Yakın sürümde olanlar çalışabilse de (örn. lab bilgisayarında Vivado Lab Solutions 2022.1, geliştirme bilgisayarında ise Vivado 2022.2 durumu iş görebilir) risk almamak adına geliştirme ve lab bilgisayarındaki yazılım sürümlerinin aynı olmasını sağlayın. Çoğu durumda zaten çeşitli hata ve uyarılar alacaksınız.
Bu sistemin çalışması için iki bilgisayarın ağ üzerinden birbirini (bir şekilde) görebilmesi gerekiyor. Önemli olan bu imkanın ne işe yarayabileceğini kavrayabilmek. Nasıl yapılacağı ile ilgili AMD’nin dokümanlarında veya başka internet sitelerinde bilgiler mevcut. Ben yine de tipik bir sistemi anlatacağım, ihtiyaçlarınıza göre değişiklikler yaparsınız.
Lab bilgisayarında Hardware Server, hw_server
, çalışıyor olması gerekiyor. Bu
yazılımın yaptığı temel iş, bir TCP portunu (varsayılan 3121) dinlemek
(server’lar bunu yapar, client’lar bağlantıyı başlatır) ve buraya bağlanan
client’ların yaptırmak istediği işleri JTAG üzerinden yapmak. Bu yazılımı JTAG
↔ TCP converter gibi hayal edebiliriz. Laf aramızda, tek bir
bilgisayarda çalışırken de aslında olan şey bu. Yani arka planda hw_server
ayağa kalkıyor, 3121 nolu portu dinliyor. Vivado, Vitis, SDK, XSCT gibi
client’lar bu sunucuya 3121 portundan bağlanıyor. Tek bilgisayar durumunda bu
bağlantı ağ üzerinden değil, doğrudan o bilgisayar üzerinde yapılıyor
(localhost
). Remote Debugging’te ise client ve server farklı bilgisayarlarda
oluyor ve bağlantı localhost
üzerinden değil de gerçekten de ağ üzerinden
yapılıyor, işin özü bu. Eğer iki bilgisayar aynı LAN üzerinde ise ve firewall
kaynaklı bir port kısıtlaması yok ise işimiz daha kolay olacak.
İlk olarak lab bilgisayarında Hardware Server çalıştırmamız gerekiyor. Masaüstü
ortamında yapmanın en kolay yolu o bilgisayardaki Vivado’yu (Lab Solutions veya
full Vivado olabilir) açmak ve Hardware Manager ile “bildiğimiz yoldan” JTAG
bağlantısını yapmak (Open Target
➔ Auto Connect
). Ama elbette doğrudan komut
satırından da hw_server
çalıştırabilirsiniz.
Burada Tcl Console
‘a bastırılan logları okursanız zaten arka planda otomatik
olarak 3121 nolu TCP portunu dinleyen bir hw_server
başlatıldığını
görebilirsiniz.
Dilerseniz Windows’un görev yöneticisinden hw_server
‘ın çalıştığını
doğrulayabilirsiniz. Linux üzerinde çalışıyorsanız ps -aux | grep hw_server
gibi bir komutla kontrol edebilirsiniz.
“Yok kardeşim benim içim rahat etmedi” diyorsanız 3121 nolu portu dinleyen bu programı PowerShell üzerinden de bulabilirsiniz (Linux’çu aslanlar da bir yolunu bulup listeleyebilirler).
Get-NetTCPConnection -LocalPort 3121 -State Listen | Select-Object OwningProcess, LocalAddress, LocalPort, @{n='ProcessName';e={(Get-Process -Id $_.OwningProcess).ProcessName}}
Yani artık lab bilgisayarı üzerinde hw_server
‘ın çalıştığından eminiz. Şimdi
yapmamız gereken şey, geliştirme bilgisayarından buradaki sunucu yazılıma
(hw_server
) bağlantı yapmak.
Geliştirme bilgisayarında ise donanıma Remote Debugging ile bağlanmak
istediğimiz zaman Open Target
➔ Open New Target
diyoruz, Auto Connect
demiyoruz:
Daha sonra Remote server
seçeneğini seçiyoruz:
Sonraki pencere Hostname
kısmına lab bilgisayarının IP’sini ya da tam adını,
Port
kısmına da lab bilgisayarında koşan hw_server
ın dinlediği port
numarasını yazıyoruz. Varsayılan olarak hw_server
3121 nolu portu dinlediği
için lab bilgisayarında hw_server
‘ı ayağa kaldırırken başka bir port numarası
vermediyseniz bu değeri bu şekilde bırakın. Eğer bu noktada hata alıyorsanız
yazının sonundaki Hata Ayıklama kısmına bakabilirsiniz.
Ben denemek için burada aynı bilgisayarda koşan
hw_server
a bağlandım (localhost
). Eğer ilerleyen ekran görüntülerinde bir yerlerdelocalhost
görürseniz kafanız karışmasın lütfen. Sizde lab bilgisayarının adı veya IP adresi yazacaktır.
Sonraki pencerede lab bilgisayarında takılı olan JTAG cihazını ve konuştuğu
FPGA’i görmemiz gerekiyor. Hardware server
kısmında lab bilgisayarının
bilgileri olmalı.
Sonraki pencerede özet bilgileri gördükten sonra bağlantıyı kurulacaktır. Bundan sonra Vivado’da kart sanki o bilgisayara bağlıymış gibi çalışabiliriz:
İki bilgisayar arasında port kısıtlamaları olabilir, 3121 nolu (veya benzer)
portu açamıyor, fakat SSH
gibi çeşitli amaçlar ile iki bilgisayar arasında çeşitli portlardan (22 gibi)
bağlantı kurabiliyor olabilirsiniz. Diyelim ki SSH bağlantısı kurabiliyorsunuz
fakat 3121 gibi portları açamıyorsunuz. İşte bu durumda SSH Tünel kullanarak
hw_server
bağlantısını SSH üzerinden yapabiliriz. Bu durumu kısaca
anlatayım.
Yukarıdaki çizimde lab bilgisayarından, geliştirme bilgisayarına SSH bağlantısı yapıyoruz. Fakat SSH bağlantısını açarken, geliştirme bilgisayarının 3122 nolu portuna gelecek istekleri lab bilgisayarının 3121 nolu portuna “tünelleyecek” şekilde açıyoruz. Bunun için SSH Reverse Tunneling yapmalıyız. Elbette bu senaryoda geliştirme bilgisayarında bir SSH server çalıştığını varsaydık. Bu bilgisayar bir Linux bilgisayar ise SSH server kurmak zaten zor olmayacaktır. Bu arada 3122 değerinin özel bir değer olmadığını de belirtmekte fayda var, başka sayılar seçebilirsiniz. SSH bağlantısını, geliştirme bilgisayarından lab bilgisayarına doğru yapacaksanız “klasik” SSH Forward Tunneling yapmalısınız.
Lab bilgisayarınız Windows ise Putty ile tünel işlemi
yapabilirsiniz. Putty’de bunu yapmak için Connection
➔ SSH
➔ Tunnels
kısmına girip aşağıdaki ekran görüntüsündeki gibi ayarları yapıyoruz. SSH
bağlantısı kurulduktan sonra artık geliştirme bilgisayarından 3122 nolu
porta yapılacak bir bağlantı, lab bilgisayarının 3121 portuna
yönlendirilecektir.
Bağlantıyı yaptıktan sonra geliştirme bilgisayarında telnet localhost 3122
yazarak bağlantıyı doğrulayabiliriz. Eğer her şey yolunda ise geliştirme
bilgisayarında çalıştırdığımız bu komut ile, SSH tünel üzerinden lab
bilgisayarında 3121 portunda çalışan hw_server
a bağlanabilmemiz gerekir.
Örnek bir çıktı:
alper@gelistirme-bilgisayari:~$ telnet localhost 3122
Trying ::1...
Connected to localhost.
Escape character is '^]'.
ELocatorHello["ZeroCopy","MicroPython","JtagFpga","DebugCore","XicomEverest",...
Gelen cevap, hw_server
ile iletişim kurabildiğimizi göstermektedir. Geliştirme
bilgisayarınız Linux ise ve Türkçe klavye kullanıyorsanız telnet
ten CTRL-ü
yaparak çıkabilirsiniz. Daha sonra telnet>
e düştüğünüz zaman quit
yazıp
Enter’a basabilirsiniz.
Bu noktadan sonra her şey aynı aslında aynı. Sadece geliştirme bilgisayarında
Remote server
bağlantısı yaparken, Host name
yerine localhost
, Port
yerine de 3122
yazacaksınız. SSH bağlantısı kopmadığı sürece bir problem
yaşamamanız gerekir.
Lab bilgisayarı olarak Linux kullanan Linux’çu aslanlar SSH bağlantısı
yaparken ssh -R
kullanabilirler, Linux’çulara komutu söyleyecek değilim, onlar
bulurlar… 😉
program_flash
Xilinx’in bildiğim kadarıyla tüm araçları, ister SSH tünel ile olsun ister doğrudan olsun, remote JTAG yani remote debugging bağlantısını destekliyor.
Örneğin program_flash
komutu ile kalıcı kod atarken -url tcp:<lab bilgisayarı
IP>:<port>
(normal bağlantıda -url tcp:1.2.3.4:3121
SSH tünelde -url
tcp:localhost:3122
gibi) parametresini geçirebilirsiniz diğer parametrelerin
yanına.
program_flash -f BOOT.bin -fsbl fsbl.elf -url tcp:1.2.3.4:3121
gibi
Benzer şekilde Vitis ile hata ayıklama yaparken New Target Connection
diyerek
ilgili IP ve port bilgilerini girerek uzaktaki JTAG cihazına bağlanabilirsiniz:
Detaylar için Vitis dokümantasyonuna bakabilirsiniz.
Benzer şekilde xsct
ile çalışıyorsanız connect
komutuna ilgili parametreleri
geçerek de uzak bağlantı yapabilirsiniz. Aşağıdaki örnekte SSH tünel üzerinden
bağlanıyorum:
xsct% connect -host localhost -port 3122
tcfchan#0
xsct% targets
1 xc7s25
2 MicroBlaze Debug Module at USER2
3 MicroBlaze #0 (Running)
xsct%
Diğer Xilinx araçları için de kendi dokümantasyonlarına bakabilirsiniz.
Karşılaşabileceğiniz hataların bir kısmından bahsetmeye çalışacağım. Yapmaya çalıştığımız iş temel olarak iki bilgisayar arasında ağ üzerinden bir TCP bağlantısı oluşturmak. Bu yüzden ağ erişim problemlerinde nasıl hata ayıklamalar yapıyorsanız o taktikleri burada da kullanabilirsiniz, burada hepsini listelemem zor. Benim tecrübeme göre çıkan hataların tamamına yakını Xilinx araçları kaynaklı değil, ağ kaynaklı oluyor. Ağ kaynaklı erişim problemlerinin çoğu portları kapatan güvenlik duvarlarından veya bilgisayardaki güvenlik yazılımlarından (Windows Firewall, Antivirüs gibi) kaynaklanıyor.
ping
atmayı
deneyin. Ağ erişimini kısıtlayan çoğu donanım/yazılım genelde ping
e izin
verecek şekilde konfigüre edilmektedir. ping
atabiliyor olmanız iki
bilgisayar arasında bir iletişim kurulabildiğini göstermektedir. Eğer lab
bilgisayarının IP adresini değil de domaindeki adını yazıyorsanız, ping
işleminin başarılı olması DNS çözümlemesinin de çalıştığını gösterecektir.Ben bu özelliği zamanında çalışma arkadaşlarıma “tatlı” şakalar yapmak için
kullanıyordum. Labta çalıştığını bildiğim bir arkadaşın bilgisayarının
hw_server
ına kendi bilgisayarımdaki Vivado’dan bağlanıp FPGA’e zamansız
resetler atarak labtan gelen Ya kart durup duruken reset atıyor, ne alaka
ya??? serzenişlerini dinliyordum. 😈 Yine de siz kararını kaçırmayın. 😇