DEV Community: Lord_Sarcastic

Rust macros in few sentences

Lord_Sarcastic — Tue, 28 Jun 2022 04:37:29 +0000

Table (List?) of content

Claimers and disclaimers
- What this article is about
- What this article is not about
Let's go (Actual content of the article)
But then... (Types of macros)
- Declarative macros
- Procedural macros
Where else can I see macros?
Thank you
Best in inclusion

So, you've been writing Rust for a few days or so; or even a few weeks or months, or years, or decades. But! you've heard macros and have been burning to know what it's all about.

Claimers and disclaimers

What this article is about

It just explains what macros are in Rust with a few references

What this article is not about

It does not:

Teach you how to create macros or how to use them
Lead you to a blissful world of Rust including the use of macros
Contain expressive code examples of macros

Let's go

Macros are simply a feature of Rust (if not the most powerful) that allows you to write code that writes other code. I'll show you what I mean:

So, let's say I wanted to write a code that ensure that when invoked on an expression or assignment or statement, would print "Hello world" before the operation is carried out; I can write a special function that would insert the line for "Hello world" in a safe place within that expression, assignment or statement. Code example in pseudocode (why? because it will take long for me to explain the actual code in Rust and I'm sure you read the Disclaimer section):

# define a macro
macro_rules hello_world (thing: expression, assignment or statement) -> Valid_Code {
    var final_code = Valid_Code();
    final_code.append('print("Hello, World!")');
    final_code.append(thing);
    return final_code.to_valid_code();
}

Then I can use my macro like so:

hello_world!(
    add(4, 8)
)

and it will print "Hello, World!" before executing the code.

You get the concept?

Now if you've got pretty good eye, you'll say "That exclamation mark after hello_world is familiar, cos I've used it to pipe content to stdout using println!". Yeah, that's because println! is a macro...

But then...

Actually, there are two types of macros you'll see:

Declarative macros

This macro tends to match against patterns and replace the code you've dropped with other code. An example of this macro is the vec! macro.

Procedural macros

These macros (there are three types of them) are more magical and tend to accept some code as an input, operate on that code, and produce some code as an output (as quoted from the Rust book). They are the ones you impose on structs like #[derive()] or the #[tokio::main] we use when using the Actix framework.

Hoping your imaginations are as wild as Abraham the Mage in The Secrets of the Immortal (very nice book I'm reading), you'll begin to see limitless ways macros can be used.

You can literally add any feature to structs, add methods to structs, attributes and so on.
You can make work easier for people when using piece of functionality like they did when Graydon's boys gave we Rustaceans vector = vec![1, 2, 3, 4] to use instead of:

let vector = Vec::new();
vector.push(1);
vector.push(2);
vector.push(3);
vector.push(4);

Where else can I see macros?

They are everywhere. From that #[derive()] syntax you see to the println! you tend to use instead of an actual debugger. The Rust Book talks more extensively about macros and you'll learn to use them more and creating them by reading that book.
You can also read The Little Book of Rust Macros to shit yourself on macros.

Thank you

Do this by liking and sharing this article with your handsome and beautiful friends.

Best in inclusion

Yeah, I know the "bold of me to assume people define friends with articles such as 'handsome' and 'beautiful'". I was hoping to use a compliment_someone! macro there, but you'll need to read the link I put up there to understand it.

San kyo :fire

Digital images: How images work

Lord_Sarcastic — Wed, 22 Jun 2022 19:53:22 +0000

Whole images on the screen hold little or no significance compared to the everyday objects you see, digital images hold much water among the wonders of computers. We'll basically be looking at how images work in this article.

Pixels (The phone copied the concept not the other way round)

So, pixels are the tiniest bit of controllable element on a display or I'd say an image. It's a hardware component on your screen (I'll show you later). So images are made up of pixels. Perhaps you've heard of the term "pixelated image" or when you refer to an images as being pixelated; well when you look at such images, you find it minutely split into neat (in my opinion) boxes of color.
While this may fascinate you if you're a weak mortal, pixels actually look like this:

Yes, you saw red, green and blue rectangles.

What are pixels made of

If you ever wrote CSS and specified colors using RGB values, this may strike a chord in the depths of your vain soul. In CSS, you do stuff like:

.some-glorified-text-no-one-will-read {
    color: rgb(255, 100, 0);
}

What this does on a lower level is specify the quantity of red, green and blue colors on each pixel that makes up the text with such wonderful class.
Pixels are really just these three lights and every colour (British English, please) is a product of a permutative combination of these three.
I'm tired, so you should read up on CMYK here.

The intensities

To produce each color, each of these bulbs are given a number mostly between 0 and 255 (255 because binary - I shouldn't tell you everything...). This then produces the venerable colours that you see on your screen.

Types of images

I cringe, quite intensely at my use of the word "types" cos it doesn't seem to me that way, but I have little say.
On the abstracted side, images... Lemme explain:
Abstracted in the sense that: "on a higher level", "on a higher power" (yes it's from Coldplay), "on the user-facing side of things";
So, "On the abstracted side, images" are represented in beatiful formats you'd recognize. I'll touch just four of them, because there are four elements in Avatar: The Last Airbender; and I love it. This is a link if you're greedy to know other formats. The four are:

JPEG
PNG
GIF
Vector Images.

They would sound familiar except you've never touched a phone before. These exist due to different tradeoffs needed to be made on the images and maybe for the fun of it. This ranges from size vs quality, compression benefits and the sorts.

JPEG (I hate it when Dillion calls it "JPENGS")

This is Dillion and he calls it "JPENGS"; however, JPEG is an acronym for Joint Photographic Experts Group, a group of nerds who love images.
The JPEG format is the most popular of all image formats and is usually the one you post every sunday. Its main focus is on giving the flexibility between image size and quality. With this, JPEG images have a maximum allowed resolution of 65,535 x 65,535 pixels. It has an extension of .jpeg or .jpg. There are a million others, but brevity >>>>>>>

PNG

This is on the layman side identical to JPEG format, except in the RGB representation, it has an extra 'A' to it referred to as 'Alpha Channel' (remember RGBA in CSS?). This 'A' has to do with transparency of an image. This means that while you can have an image with a transparent background with PNGs, you can't have such with JPEG images. By the way, it is legal to pronounce 'PNG' as 'Ping. Actually, non-rgb formats are not allowed in PNG, so bye-bye CMYK (it's not even fine to pronounce in the first place). It's extension is .png.

GIFs

GIF is an image format that literally gives you a movie but with images. If you ever saw those images that moves on Whatsapp (well, I prefer stickers), you're seeing a GIF in action. GIFs are image formats that have animation support, except you're limited in the number of colours you can use, namely 256 (yes, binary).
This is a GIF:

Vector Images

Rather than deal with pixels, vector images are based off calculations. This means the position of each content in the image is actually calculated dynamically so you can have infinite pixels for one image. This means that you can scale up a vector image without losing quality. They are generally used for icons and fonts on this page you're reading.

Cooking images

Well, this section refers to image manipulation and stuffs you could do with images. I've outlined three here:

Cropping

If an image is too big or if there are some parts you don't want to show, you can crop it. Cropping will remove sections of the image and focus attention on other parts of your picture. It's like amputation but for images, and there's no blood. Only unhappy pixels.

Contrast

Changing the contrast will make the image duller or more vibrant. Changing the brightness will make the image lighter or darker. You can manipulate the contrast of an image making it look better through contrast. Check your favourite photo editor for this option. It's quite neat stuff.

Scaling

Sometimes you want to resize an image, which means making it bigger or smaller. Pixel-based images can be made smaller but when you increase the size they will lose quality and pixelate. This is because scaling up a pixel is quite dicey and would show the individual colors in the boxes as they are. I'm sure you don't like it. Vector graphics can be resized without any change in quality.

Image compression

Image compression is really just reducing the size of images. I use a Redmi Note 10 Pro and images sometimes get up to 15 - 20 MB, especially with good lighting. This is an evil thing and exorcism does not work so, they invented image compression for my sake.
There are two types (I have mood swings, so they created two):

Lossy compression

Lossy compression works by removing some of the data in the image binary. The quality of the file will be reduced. If you're not so concerned about quality, you'd want to use this form of compression.

Lossless compression

Lossless compression works by rewriting the data so it is stored more efficiently. Read up on data compression here. The quality of the file will stay the same. In this case, you can be rest assured your body parts will remain intact in the image. However, not all image formats supports this type.

Other fun stuffs about images you'd want to know

A video is essentially lots of images shown in a small frame of time. They are called frames. The more frames per second, the smoother the video… Play games more, you’ll see these stuffs
Filters on apps such as Tiktok (such a lovely creation) and Snapchat (such despicable thing) are made by simply solving calculus with pixels. No time to explain, you should have listened in maths class.
You can manipulate your own images too. Check out the Pillow library in Python to see how you can do stuffs like these.
Resolution is usually how many pixels you have per metric unit… See DPI and MPs
You can send images from one device to another. Surprising, no?

Some....body

So, Abiodun, a venerable colleague at Formplus, seeing my activities concerning images, enlightened me on signal processing and dropped resources you'd love.
Now, you may have wondered how Google Meet knows where your head is so they'll blur your background. Well, it has to do with those mathematics we all hated in school: matrixes, laplace transforms and (literal tears here) calculus things. With algorithms, computers are able to detect images and object in the context of another image. If you're interested in the how a wonderful algorithm like Haar's Transform, can be used for face detection and object detections, look here.
Love Python and want to see some other algos? here are some of them.
Lastly, on scaling images and compression, Fourier Trasform (I'm sorry, I also had PTSD from seeing this too) is useful and you can see its applications.

Conclusion

Now, child, I have shown you the best of my knowledge on images, formats and types, how to cook them and how to serve them.
This blog post is my first in months and only due to a presentation I made on images. These are the slides.

If you want to know about Isaac, a fellow who is usually a core individual in my articles, read my previous article on What's that *args stuff in Python

What's that *args stuff in Python?

Lord_Sarcastic — Thu, 14 Oct 2021 03:10:39 +0000

We've all called functions or methods of a class and then we see our editor show stuffs like so:

The focus is on *values part of the picture.

Most times, we just use the thing and go our way.

In this post, we'll see the purpose of that asterisk stuff (usually called *args) and how to use it to eliminate boredom and reduce tension in our Python functions and methods.

The problem

Y'all remember Isaac? Well, he's got a problem here.

Isaac has been employed by Genghis Khan, one of the greatest men the world will ever see, to automate the process of ending the lives of his enemies.

This is Isaac's second serious job and he is ready to impress the Emperor of the Mongol Empire, so he creates an dispatch_foe function that accepts a list of names of people and then reduce pollution by doing what is necessary.

He churns a function like so:

from GenghisKhan.actions import kill

def dispatch_foe(name: str) -> bool:
    success: bool = kill(name) # ends the life

    return success

The issue

Calling this function on lots of people involves doing something like so:

for name in list_of_names:
    dispatch_foe(name)

This could be quite laborious for the soldiers involved and only does the dirty work for them. It does not really automate lots.

A small solution

Well, Isaac then decides to make his function accept a list of the names and then do the rest:

from typing import List
from GenghisKhan.actions import kill

def dispatch_foe(names: List) -> bool:
    success: bool = True
    for name in names:
        success = success and kill(name) # tells us if and only if everyone died

    return success

and we can call dispatch_foe like so:

# people who we both share mutual hate
enemies = ["Erons", "Victor Aiyeola", "Davidemi"]

# test to confirm that they were successfully dispatched
assert True is dispatch_foe(enemies)

An actual solution (The why)

While Isaac's solution works, it is stupid. Why? Simply because if we accept it, I'll never be able to teach you what *args does. That means you'll wallow in complete ignorance till the end of your life span.

This has a dangerous effect. In the event the life of someone can only be saved by *args, our refusal to reject Isaac's answer will spell the end of that person who may be a key soul to solving world hunger and therefore lead to millions and billions of deaths. This is why we always have to reject Isaac's first solution to solving any problem.

Actually... lol

Most times, you'd want your function to accept a variable number of arguments without specifying a default. *args is a beautiful and pythonic way to do that.

So we'd use it instead of lists or tuples or dictionaries (ah, there's a trick to this one, I'll write an article on it someday) or sets or arrays or vectors or linked lists or doubly linked lists or triply linked lists or quadruply linked lists or ...

An actual solution (The real stuff, without ment attached)

So, we'll rework Isaac's solution so soldiers can pass as many enemies as possible without having to pack them into a list:

from typing import Sequence
from GenghisKhan.actions import kill

def dispatch_foe(*names: Sequence[str]) -> bool:
    success: bool = True
    for name in names:
        success = success and kill(name) # tells us if and only if everyone died

    return success

and we can call our function in different ways like so:

# 'do' Erons alone
assert True is dispatch_foe("Erons")

# 'do' Erons and someone else
assert True is dispatch_foe("Erons", "Someone else")

# 'do' people who hate me
assert True is dispatch_foe("Erons", "Davidemi", "Victor Aiyeola")

The end

And there, little mortal one, is an elegant solution to Isaac's problem. Genghis khan did use Isaac's solution for solving the problem of enemies. Unfortunately, Isaac's name isn't in the history books. Yeah because some organizations and some successful products don't give their engineers enough praise.

It's important to know that the '*' character was introduced by PEP448 and is usually referred to as iterable unpacking operator.

Know also, that the usage of *args and **kwargs (we'll learn this later) can make debugging quite evil. So you'd want to watch your back whilst using them.

Disclaimer

There is no GenghisKhan module implemented anywhere in the Python standard library or Pypi index or anywhere. No murders were committed in the course of this code and my enemies are excellent engineers with happy jobs (I don't have one, so I don't like them at all).

Also, there is no proof that Genghis Khan actually asked Isaac to write this function. I must have written this article while dreaming.

The actual end

May the force of the snaky language dwell richly in your soul and may you find what is that good, pleasing and perfect will of The One Above All.