DEV Community: Buğra Yıldız

Basic Arithmetic in Assembly

Buğra Yıldız — Tue, 14 Sep 2021 02:57:11 +0000

Hello there!

So basically I just figured out how to do those 4 simple operations (adding, diving etc.) in assembly, because I need to be able to do maths in my own programming language. So here's the recap of all the pain I've been through thanks to intel:

This article is useful for people using intel x86_64 architecture with the GNU assembler, gas. You also have to use .intel_syntax noprefix macro so you can use the intel syntax, which this tutorial uses.

Addition

First things first, get your values into your 64 bit teeny tiny registers:

mov rax, 1
mov rbx, 2

The rest is pretty simple:

add rax, rbx

The result is in rax, which is 3.

Subtraction

Same as always:

mov rax, 10
mov rbx, 2

Then again:

sub rax, rbx

The result is in rax, which is 8.

Multiplication

So, this one instruction actually has 2 ways of using it, but for the sake of simplicity, I will show you the easiest one, which is most likely erroneous because if you are writing a production ready compiler or the production code directly you HAVE TO check if multiplying two 64 bit numbers result in a 128 bit number, because if it does your result will be incorrect. But who cares right?

mov rax, 5
mov rbx, 2

Then a simple operation:

imul rax, rbx

Aaaanndd, the result is in rax, which is 10.

Division 🤢

So, this one is probably the messiest within the four, but here we go ladies and gentleman. This instruction takes only a single, explicit argument and an implicit argument. But using it with a little hack is pretty easy. Firstly, unlike any other instruction up until you have seen, this one requires that the dividend MUST be in the rax register.

mov rax, 100
mov rbx, 5

Then, before diving it you have to put this instruction for some complicated reason, which affects registers rdx and rax. I will tell more in a minute, but just divide by then:

cqo
idiv rbx

Your result should be in rax, and the remainder of this operation is in register rdx.

The problem with dividing is that, because it affects other registers that you don't mention, often times when rax and/or rdx has values you actually have to store them somewhere. One way to get around this is using the stack:

note that you can put them in unused registers too!

# store those values on the stack
push rax
push rdx

# divide
mov rax, 100
mov rbx, 5
cqo
idiv rbx

# move the result to unused registers
mov r8, rax
mov r9, rdx

# then retrieve back those values, notice the order is reverse!
pop rdx
pop rax

Conclusion

I don't hate intel, but that way of dividing is uhhh... Nevertheless, this is a funny thing to know and pun your coworkers because you can do maths in ASSEMBLY now and they can't cuz they have a life and shit. Can't understand humans, see you later!

The Biggest Trade-off

Buğra Yıldız — Mon, 15 Feb 2021 14:28:53 +0000

What is a trade-off?

A trade-off is, in its simplest form, a choice someone makes when stuck between two beneficial facts. You sacrifice one fact to have the benefits of the other because they can't possibly co-exist.

In software development, we make trade-offs all the time. They rarely ever are of great significance in terms of the program's performance, memory consumption, storage usage, etc although choosing the right one is important and usually depends on the situation. But there are trade-offs where it is not related to the choices we make when building the software, but choices we can't make when building it, which are of a much bigger concern to us.

Things we can choose.

For example, in JavaScript instead of using map() you can choose to use a regular for loop where performance is critical. Or you might use a different algorithm that performs faster but uses more memory because even though you have sufficient amounts of memory you lack the processing power required to meet the demand.

Such decisions are easy to make, and usually take a couple of seconds once you decide what is more crucial in the given context. However, there are:

Things we can't decide.

For example, let's consider a simple case. You live in a 3rd world country where the internet is awful & hardware is expensive as specially bred utterly fluffy dogs & cats.

Can you run docker to learn it?
Can you run Chrome with Vscode or Atom at the same time?
Can you pair program with your mates whilst speaking over Discord and writing code using the great live-share plugin with other extensions you may need to write good code?
Can you even use a proper operating system?

The answer is no, you most likely can't. You are stuck with a minimalist non-popular Linux distro that may or may not run your stuff, a Vim config which is next to nothing compared to an IDE feature-wise, and a very basic low-level compiler because interpreted languages with optimizing JIT compilation features on top with utterly broken & slow package managers are of a massive deal to your old crappy hardware and horrible internet. You sacrifice your lifespan waiting for your project to get dependencies, compile & run. That's the biggest trade-off. Got no money for better equipment? Sacrifice a couple of hours of your life, that'll do!

Evidently, you are as invaluable as bok-bags to many recruiters. Not because you lack in skill, determination, experience, and all the things that ARE significant for software development, but because you lack in equipment needed.

What's the point then?

I ask myself this, every damn single day. What's the point in embracing software development if you can't even do the simplest Hello World? Why forcefully try things that are impossible to do for you? Why?

The answer is always the same, man do I LOVE it don't I?

Yes, yes, I confessed. Pun me about it and all. But seriously, I love it way more than I should. Every day I think about it, when I wake up, whilst eating, when sleeping in my dreams. I see videos about programming in my YouTube feed, I consequently have subscribed to all the subreddits about programming because I get to have so much fun reading, watching, reasoning about them. In all of my social media accounts, there is at least one post that I've shared my happiness with the programs I've written & things I have learned recently that are about programming.

When all the odds are against you, and they give you only agony, seemingly massive in quantity, if you still hold on for some reason, that thing is called love. And if you love programming, there's no going back. For everybody who doesn't have those fancy Macs, with pretty setups or fast internet (or no internet at all) access, keep holding on. Because chances are, something will happen and you will be in the place that you have always dreamed & been longing for this long. Someday all your pain will become a genuine smile into your past. You'll look back and say "what days have begone". It all will seem like a dream. A dream where you fought, and won.

Keep fighting, your enemy is probably more stupid and less powerful than you think. Good luck in life,