DEV Community: Ahmed Mannai

The Multifaceted Nature of Programming

Ahmed Mannai — Thu, 19 Oct 2023 09:19:20 +0000

Hello World.

I remember the day I first dipped my toes into the world of coding. Back then, I had a rather simplistic view of software engineering. It felt as if software engineers possessed the uncanny ability to crack code out of their fingers onto the screen, as if they had all the answers stored away in their minds and merely needed to type them out. But I couldn't have been more wrong; that's not coding; it's just typing or whatever you want to call it, really.

When I began my journey into coding, I was primarily focused on solving algorithmic problems. These problems seemed deceptively simple. I would just visualize the solution in my mind, and it was as if the code was writing itself on the screen. It was almost magical in its simplicity.

However, the transition to real-world projects was nothing short of a seismic shift. Coding, I realized, was not the act of typing out pre-conceived solutions. It was a multi-faceted process involving more than just typing. It was about searching for documentation, reading it, and then re-reading it. It was about debugging, refactoring, and constantly rethinking my code. It became a relentless cycle of learning, doing, and redoing.

One vivid memory from my internship still lingers in my mind. We faced a problem that appeared fairly unique. No one seemed to have documented it online, and we were stumped. I spent nearly 8 hours straight, poring over one documentation after another, from one GitHub repository to another, trying every conceivable approach. In the end, it all came down to a single line of code that fixed the entire issue. You might think it was a colossal waste of time, but it was the only way forward. There were no shortcuts.

Speaking of shortcuts, I've learned the hard way that they can be the bane of a software engineer's growth. It's tempting to follow tutorials, copying and pasting code without fully comprehending why it works. It might help you go from point A to B quickly, but when it's time to go from B to C, you'll find yourself lost, struggling to adapt the copied code to your needs.

However, this is what makes us love coding. It's the thrill of problem-solving, the joy in searching for and discovering new information, and the relentless pursuit of the most optimal way to convey your intentions to a computer. That is the essence of coding.

The flow of coding is not about shortcuts; it's about the journey. It's about delving into the unknown, taking on the challenge, and arriving at the solution with an enriched understanding. It's about the satisfaction of seeing your code come to life and the realization that coding is not just about typing but about thinking, solving, and creating.

In conclusion

In conclusion, coding is far more than a mere act of typing lines of code. It's a complex, multi-faceted process that involves dedication, problem-solving, and a relentless pursuit of knowledge. The true essence of coding lies in the joy of the journey, in searching and discovering, and in the pursuit of the optimal way to communicate with a computer. It's not about shortcuts; it's about the thrill of cracking the code.

You can see more article like this on ahmedmannai.me/blog

How to insert a responsive YouTube Video to react using Tailwind CSS

Ahmed Mannai — Tue, 12 Sep 2023 11:40:49 +0000

Liquid syntax error: Unknown tag 'endraw'

how to communicate with a serial port using flutter_libserialport package

Ahmed Mannai — Tue, 24 Jan 2023 13:59:15 +0000

Hello everyone! Don't you just hate when documentation is scarce and tutorial blog posts are almost non-existent for something you're working on? I've been there. I was working on a Flutter app pertinent to serial port communication and faced the same issue. But now that I've figured it out, you don't have to feel the frustration that comes with the lack of guidance.

By the end of this blog post, you'll learn how to send and receive data through a serial port using Flutter. Let's dive in!

## Getting Started

To start with, we need to add the package named flutter_lib_serial_port to our empty Flutter project. We will then import the lib_serial_port package that we just downloaded.

Here's a bit of code to assist you:

import 'lib_serial_port.dart';

Identifying Available Ports

Once the package is successfully imported, the first thing we need to do is to identify the available ports connected to our PC.

To do that, we will declare a list of strings that will receive the names of the available ports.

List<String> availablePorts;availablePorts = SerialPort.availablePorts;print (availablePorts);

On running this code, you should see a list of the available ports. In my case, there were only three ports, labelled as serial port.

Creating a Serial Port Object

Now we'll need to create a serial port object, let's call it portOne. This object requires the name of the port we got from our list of available ports.

SerialPort portOne = SerialPort('serial_port_three');

The above code will create an object referenced to 'serial_port_three'

After creating the object, it's best to use a try-catch block to handle any serial port errors. If an error occurs while reading or writing to/from the port, we simply print it to the console.

Opening the Port for Communication

Now we can open the port for communication. The openReadWrite method enables opening the port for both reading and writing.

Let's implement that in our code:

portOne.openReadWrite();

Writing to the Port

After successfully opening the port, we can write to it. We have a problem though; the write method takes a Uint8List but what we have is a string.

To make the conversion, a method needs to be created that converts a string to unit8List. The return type of the write method will be the bytes written. Let's print these bytes written to check if the data was written successfully.

Here is how to do it:

String str = 'Hello';Uint8List uint8list = Uint8List.fromList(str.codeUnits);print (portOne.write(uint8list));

On executing this code, a number (5) will be printed, which corresponds to the length of the string 'Hello', indicating the successful write operation.

Reading from the Port

Now let's implement the functionality to read from the serial port. To achieve this goal, we need to create a serial port reader object.

This object provides us with a stream, which we can listen to, and then print the incoming data. The problem here is that the stream returns unit8List data, thereby necessitating the conversion back to a string.

Here is the code snippet to do this:

SerialPortReader reader = SerialPortReader(portOne);reader.stream.listen((data) {print(String.fromCharCodes(data));});

If you've followed along correctly and everything goes without a hitch, you should be able to read data from the serial port successfully!

"Don't be discouraged by what you don't know. That can be your greatest strength and ensure that you do things differently from everyone else." - Sara Blakely

I hope you've found this tutorial useful. Remember, in technology, the best way to learn something new is by doing. Happy coding, and until next time, take care!

Why Programming is FUN

Ahmed Mannai — Sat, 21 Jan 2023 14:41:02 +0000

You start programming and all of a sudden, you have lost connection to the external environment, times flies by without noticing it. all your psychic energy is directed towards fixing that bug or make that code works.
let's be honest guys challenges are what makes programming fun and bugs are no exceptions.
facing a problem while coding and work hard to solve it puts our mind in a state of Flow.
programmers experience flow when they are fully immersed in the task at hand and in a state of optimal performance.

wait what is flow ?

The term "flow" was first introduced by psychologist Mihaly Csikszentmihalyi (pronounced six-cent-mihaly) to describe the experience of being completely engrossed in an activity, where time seems to fly by and self-consciousness disappears. This state of flow is characterised by a feeling of effortless concentration, full engagement in the task, and a sense of control and mastery over one's actions.
in his book he goes deep into flow and what makes us happy.

Programming and Flow

In programming, flow can be experienced when a developer is fully absorbed in the process of creating and solving problems, and the code is flowing easily from their mind to the screen. This state can be incredibly productive, as it allows developers to focus on the task at hand without getting bogged down by distractions or self-doubt.

To achieve flow, a number of conditions must be met. The task at hand must be challenging but also achievable, with a clear goal and a sense of progress being made. Developers must also have the skills and knowledge necessary to complete the task, and they must be free from distractions and other sources of stress.

When the conditions for flow are met, the experience can be incredibly rewarding. The sense of control and mastery that comes from solving complex problems can lead to a feeling of satisfaction and a sense of accomplishment. In addition, the state of flow can lead to increased creativity and problem-solving abilities, as well as improved productivity and code quality.

In my experience it is the same like playing a good football game where you have no idea about the external environment,
you mind is executing one and only one thing (one task). you wouldn't believe me when I tell you that those moments are what makes us happy.

The problem is that this state is not easy to achieve and it can be easily interrupted. The biggest obstacles are procrastination, lack of motivation, poor environment and bad habits that impede the concentration.

One way to overcome these obstacles is to actively work on developing good programming habits, such as setting clear goals, breaking down large tasks into smaller, more manageable chunks, and minimising distractions by working in a dedicated, comfortable and organised work environment.

have fun while coding and good bye.