DEV Community: Binamin

Why Preprocessor Is Essential In C

Binamin — Mon, 18 Sep 2023 07:33:13 +0000

Preprocessor in C refers to the essential steps performed before the compilation of a C program. To understand this better, take the example "Food" Cooking rice is the processing while collecting all ingredients in the right amount performing all the steps comes under preprocessing. Now let's discuss the concept of preprocessing in C.

The Concept Of Preprocessor

Any teacher in a class of English lesson will tell you that, When you are adding two words together it is called a compound sentence. Now break the sentence into two and you will get two words for instance "Firewood" becomes Fire +Wood. Same with the preprocessor. "Pre" means before and "processor" means making something. A program is automatically preprocessed using various preprocessing directives in C before it is compiled in the C programming language.

Understand this, you cannot have a clean code without a preprocessor. To understand this better, assume you are in a field, and both the two teams are on the pitch but there is no ball, would they play? Definitely No, right, what would they play with? If you have written even one C program, you will know that it all starts with #include. It is called a header statement. Now do this, write include without the # symbol and run the code in your IDE, you will realize that it brings an error message so this means it is important that the # hash symbol be written so that the code runs cleanly.

Key Features In Preprocessor
File inclusion. The #include directive let you include a header file that contains the declaration and definitions needed for your code. This promotes modularity and reusability allowing you to separate interface and implementation detail. Examples in code

#include <stdio.h>

Macro definitions. The #define directive allows you to create macros which are symbolic names for values or code snippets. Macro enhance code readability and mountability by providing meaningful names for constant or compiler expression

#define MACRO_NAME value

Conditional compilation. Directives like #ifndef #ifdef #else #endif enable conditional compilation. This enables you to include code sections based on specific conditions such as compiler flags or platform differences.

   #ifdef DEBUG
       // Debug-specific code
   #else
       // Release-specific code
   #endif

Pragma direction. This provides a way to give special instructions to the compiler such as optimisation setting or alignment requirements

Debugging and Testing. Conditional compilation allows you to insert debugging statements or enables testing code without affecting the final production version.

Portability Different platforms and compilers might require specific adjustments. Preprocessor directive enables you to write code that adapts to different environments without rewriting a large portion of the code.

In summary, the preprocessor act as a text manipulation tool that prepares the code before it goes through the main compilation process. It plays a pivotal role in making C code more modular, readable, adaptable and efficient by providing a mechanism for code separation and customization.

Everything About Open Source Projects That You Need To Know.

Binamin — Wed, 13 Sep 2023 06:54:44 +0000

Starting an open-source project or contributing to an existing one is a rewarding endeavor that can improve your programming skills, build your professional network, and provide solutions to problems for the wider developer community. Here's a step-by-step guide on how to get started:

1. Identify a Problem or Interest
Before starting or choosing an open-source project, it's crucial to identify a problem you want to solve or an interest you're passionate about. This could be anything from a tool you wish existed, a feature you think would improve an existing project, or a bug you want to fix

2. Choose a Project

If you're contributing to an existing project, choose one that you use and love. It's also important to ensure that the project is active, with recent commits and responsive maintainers

3. Know the Project
Get to know the project by reading its documentation, understanding its features, and familiarizing yourself with its codebase. This will help you understand what the project does and how it can be improved

4. Make a Contribution
Contributing to an open-source project can come in many forms, from code contributions to non-code contributions like graphic design, project management, testing, bug reports, documentation, and community management. Regardless of your skill level, there are opportunities for you to contribute

5. Start Your Own Project

If you're starting your own open-source project, there's no perfect time to do so. You can open source an idea, a work in progress, or after years of being closed source. However, you should feel comfortable having others view and give feedback on your work. Also, ensure to include necessary documentation and an open-source license to protect your work and allow others to contribute

6. Build a Community
Creating an open-source project is not just about the code; it's also about building a community that encourages people to use, contribute to, and evangelize your project

contributing to open source is not just about helping others; it's also about improving your skills and gaining experience in the process. As you continue contributing or managing your project, you'll learn valuable lessons about software development, project management, and collaboration.

An In Depth Guide To Functions In JavaScript

Binamin — Tue, 12 Sep 2023 09:37:27 +0000

in javascript, there many ways to create a function.

function declaration
function expression
arrow function
function invocation

Function Declaration

just like how a variable declaration binds a value to variable name, function declaration binds a function to a name or an identifier.

A function declaration is a function that is declared as a separate statement in the main code flow.

  syntax is as follows

function functionName(parameters){
//code block
}

examples

function name(){
console.log('What is your Name?');
}

function declaration in javaScript are hoisted to the top of the enclosing function or global scope. This means you can use the function before you declare it.

A function declaration consist of

The name of the function or it is identifier followed by parenthesis
A function body or the block of the statement required to perform a specific task enclosed in the function curly braces.

calling a Function

A function declaration binds a function to an identifier however, a function declaration does not ask the code inside the function body to run , it just declare the existence of the function. The code inside a function body runs or execute only when the function is called. You can call a function directly by using its name followed by parentheses (). If the function takes an argument you can pass them inside the parentheses separated by comma.

                greet world();

This function call execute the function body or all of the statement between the curly braces in the function declaration

         examples

    function greet(name){
  console.log('Hello ' + name);
}
greet('Binka'); // This will log: "Hello Binka"

Here's what's happening in this code:

Function Declaration: function greet(name){ ... } is declaring a function called greet that takes one parameter, name.

Function Body: Inside the function, there's a console.log statement. console.log is a function that prints whatever is inside the parentheses to the console (usually your browser's developer tools or your terminal).

String Concatenation: The + operator is used here for string concatenation.
function call: greet('Binka') This line of code is calling or invoking the function greet with argument 'Binka'
finally the greet function will log 'Hello Binka' to console.

PARAMETERS AND ARGUMENTS

So far the function we have created execute a task without an input. However, some function can take inputs and use the inputs to perform a task. When declaring a function we can specify its parameters. Parameters allow function to accept inputs and perform task using the inputs. We use parameters as placeholders for information that will be passed to the function when it is called.
syntax for declaring parameters in function declaration is as follows

function functionName(param1, param2, param3){
//.....
}

each parameter is separated by comma

   examples

function calculateArea(width, height) {
  console.log(width, height);
}

Now, let's break down the code:

Function Declaration: The code begins with function calculateArea(width, height) { ... }, which declares a function named calculateArea that takes two parameters: width and height.

Function Body: Inside the function, there's a console.log statement that logs the values of width and height to the console.

console.log(width, height);

This line of code will output the values of width and height to the console when the function is called with appropriate arguments.

It's important to note that the provided code only defines the function. To execute the function and see the output, you need to call it with specific arguments.

For example:

calculateArea(10, 5);

In this case, the function calculateArea is called with the arguments 10 and 5. The values 10 and 5 will be assigned to the width and height parameters respectively, and the function will log these values to the console.

RETURN

When a function is called, the computer will run through the function's code and evaluates the result of calling the function by default that the result is undefined.

function rectangleArea (width, height){
let area = width * width;
}
console.log(rectangleArea(5,7))

The function does not have a return statement. As a result, it won't return any value when called.
To fix this, we will need to add a return statement to the function to return the calculated area:

function rectangleArea(width, height) {
  let area = width * height;
  return area;
}

Now, the function will calculate the area of the rectangle based on the width and height parameters and return the result.

Calling the Function: The code includes a console.log statement that calls the rectangleArea function with arguments (5, 7). However, since the function doesn't return anything, the console.log statement will output undefined.

Return allows functions to produce output.

conditional Statement In Javascript

Binamin — Sat, 09 Sep 2023 13:50:08 +0000

conditional statement in javaScript allows you to execute different blocks of code depending on whether a specified conditions conditions evaluates to true or false.

       ****TYPES OF CONDITIONAL STATEMENT IN JAVASCRIPT****

If,else if and else statement
comparison operator
logical operator
Truly vs falsy values
Ternary Operator
Switch statement
```
 **IF STATEMENT**
```
We often perform a task based on a condition for example, if you have Money, you go outside, if you are hungry, you eat and if you are tired, you go and sleep. In programming, we can perform a task based on a condition using if statement.

examples

if (false){ console.log('This will be false');

Notice in the example we have an 'if' statement. The if statement is composed of the if keyword followed by a set of paranthesis which is followed by code block or block statement indicated by a set of curly braces {}

Inside the paranthesis(), a condition is provided that evaluates to true or false.
if the condition evaluates to true, the code inside the curly braces runs or execute. If the condition evaluates to false, the block will not execute.
```
**IF ELSE STATEMENT**
```
If we wanted to add some default behaviour to the if statement, we can add an else statement to run a block of code when conditions evaluates to false
```
   if(false) {
console.log('The answer will not be executed');
```
} else{
console.log('But this answer will be executed');
}

an else statement must be paired with an if and together they are called if...else statement.

In the example above,

use the else keyword following the code block of an if statement.
Has a code of block that is wrapped by a set of curly braces {}
The code inside the else statement code block will execute when the if statement conditions evaluates to false.

it is important to note that, an else statement does not take another condition therefore, it will not have a set of paranthesis.

COMPARISON OPERATORS

When writing a condition statement, sometimes we need to use different type of operators to compare values. These operators are called comparison operators. These include

less than <

5 < 10 // true
'apple' < 'banana' // true

greater than >

10 > 5 // true
'apple' > 'banana' // false

less than or equal to <=

10 <= 20 // true
'orange' <= 'banana' // true

greater or equal to > =

20 >= 20 // true
'orange' >= 'banana' // false

is equal to ===

5 === '5' // false
5 === 5 // true
'hello' === 'world' // false

is not equal to ! ==5 !== '5' // true 5 !== 10 // true 'hello' !== 'world' // true

comparison always compares the value on the left with value on the right.

      **LOGICAL OPERATORS**           

  working with conditions means that we will be using booleans that is true or false value. In Javascript, there are operators that work with booleans value known as logical operator. We can use logical operator to add more sophisticated logic to our condition. There are three logical operators

end operator (&&)
the or operator ( ||)
the not operator ( !)

when we use the && operator, we are checking that two things are true.

if (stopLight === 'Red', && 'pedestrian' === 0){ console.log('Go!'); }else{ console.log('stop!); }

when using the && operator,both condition must evaluate to true and execute otherwise if either condition is false, the && condition will evaluate to false and else block will execute.
if we only care about either condition being true, we can use the or || operator
if(month === 'April' || month === 'May'){ console.log('Enjoy your month!'); }else{ console.log('Get to work'); }

when using the || operator, only one of the condition must evaluate to true for the overall statement to evaluate to true in code above, if either Month === 'April' or month === 'May' evaluate to true. The ifs condition will evaluate to true and its code block will execute. If the first condition in an || operator evaluates to true, the second condition will not even checked. Only if Month === 'April' evaluate to false will month === 'May' be evaluated. The code in the else statement above will execute only if both comparison evaluates to false.

The ! operator reverse negates the value of boolean

  let excited = true;
   console.log(excited); `

   let tired = false;
    console.log(tired);`

Essentially, the ! operator will either take true value and pass back false or take false value and pass back true.

         **TERNARY OPERATOR**

In the spirit of using short hand syntax, we can use ternary operator to simplify.
take a look at this if...else statement

let isNightTime = true; if(isNightTime){ console.log('come home'); }else{ console.log('come home'); }

we can use ternary operator to perform the same functionality.

isNightTime ? console.log('come home') : console.log('come home');

In the above example;

The condition isNightTime is provided before the ?
Two expression below the ? are seperated by a colon
if the condition is true, the first expression is executed.
if the expression is false, the second executes.

That is all for this blog. We will discuss the other conditions on my next Blog.

The Fundamental Concept For JavaScript Beginners

Binamin — Sat, 09 Sep 2023 07:07:42 +0000

JavaScript is a programming language used for Web development. It is used alongside HTML And CSS.
Now if you have already learnt HTML and css, you would not have hard time learning JavaScript.
JavaScript is very important and if you are here, it means you really want to learn.
Before we start the content itself, it is good to know what you would be up against.
These are JavaScript Road map.

Introduction to Basics. This include Variables, data types, basic operator
Function and control structure : grasp the concept of function, how they work and their importance, learn about if else statements for decision making and explore loops for repeative task.
DOM Manipulation: understand how JavaScript interact with document object model, learn how select, modify and create HTML, explore event handling and attaching event listener.
Asynchronous JavaScript : Dive into asynchronous programing and event loop and learn about callbacks, their role in managing asynchronous operation
ES6 + Features: study modern JavaScript features like arrow functions, templetes iterates and deconstructing, explore let and cons for variable Declaration and block scope.
Build Projects : apply your knowledge by building simple project and build project like to do list and calculator.
Debugging And Troubleshooting
Libraries and Framework
9.Read World Applications

Introduction To Basics

These basics are like data type, variables, basic operation etc.

     **VARIABLES**

in programming, a variable is a container for a value. You can think of variable as a little container for information that lives in a computer memory Information stored in variables such as username, account number or even personalised greetings.

Variables also provide a way of labelling data with a description name. It is important to note that variables are are not values but they contain values and represent them.
Variables include
1. let
2. var
3. const

1. **Var**

Before 2015,programmers use to declare only var. It is used in the pre ES-6 version of JavaScript.
You can declare variables using "var"
Example

var myName = "Binamin";
console.log(myName);

//output: Binamin.

In these examples, var short for variable is a JavaScript keyword that create or declare a new variable. MyName is the variable name. Capitilising in this way is the is a standard convention in JavaScript called CAMEL CASING. In camel casing, you group word into one, the first word is lowercase then every other word that follows will have it is first letter uppercase.
=is the assignment operator.
"Binamin" is the value assigned to variable myName
After variable is declared, the string value "Binamin" is printed out to the console.
Rules For Naming Variables

variable name cannot start with a number
variable name is case sensitive so myName and myname would be a different value

  2. **Let Variable **

Let is the preferred way to declare a variable when it can be re assigned.

Examples 

let food = "chips";
console.log(food);

//output:chips
From this example, we have declared a variable called "Food" using keyword "let" and assign the value "chips" then we log the value of food to the console. It will output "chips"
Another concept we should aware when using let and var is that we can declare a variable without assigning the variable a value.in such case, variable will be automatically initialize with value of undefined.
Examples

let price;
console.log(price);

//output: undefined

 price = 350;
 console.log(price);

//output: 350

 3. **Const Variable**

Just like var and and let, you can store any value in a const variable. The way you declare a const variable and assign a value to it follow the same structure as let and var

  const myName = "Binka";
  console.log(myName);

//output: Binka

However, a const variable cannot be reassigned because it is constant. If you try to reassign, you get type error.
Const variable must be assigned a value when declared. If you try to declare a const variable without value, you will get syntax error.

    **DATA TYPES**

Data types defines the type of values that can be used in your code.
There are several data types in JavaScript which are categorized into two two main group.
Primitive Data type
Reference Data type

**Primitive Data Type **

These include:

Number: Represent the numeric values including integers and floating point.
For instance

Let age =20;
let price = 50.87;
String: These are primitive data type. There are any groups of characters which include letters, spaces, numbers or symbols sorrounded by single quote or double quotes.

Example

Let Hamy ='where are you from?';

Boolean: These are primitive data type. They can be either true or false.
Example

let goingHome = true;
let goingHome = false;
Null: is a primitive data type. It represent the intentional absence of values in code. It is represented as a null.

let Brik = null;

Undefined : is a primitive JavaScript data value that represent lack of defined value. Variables that are declared but not initialized to a value will have the value of undefined.

var = a;
console.log(a);
//prints: undefined

*Reference Data Type *

Reference data type in JavaScript are data type that do not directly contain data but instead referenced it by storing memory addresses or reference to data location.
It include:

Object:it represent collection of key Value pairs enclosed with curly braces.
Examples

let football = {
England: "Premier league",
Spain : "La Liga",
};
Array : This one represent ordered list of values enclosed in a square bracket

Examples

Let name = [ "Binka", "John","Ankit"];
console.log(name);
//output:Binka,John, Ankit.
Function: it represent a reusable block of code that can be invoked.

Example

function add (a, b){
return a + b;

}

That's the basics introduction to JavaScript. There are still more that I will cover.

The Concept of CI And CD in Devops.

Binamin — Fri, 25 Aug 2023 11:33:31 +0000

Introduction:

In the fast-paced world of software development, efficiency, and reliability are paramount. Enter Continuous Integration (CI) and Continuous Deployment (CD), two essential practices that form the cornerstone of the DevOps philosophy. In this blog, we'll delve into the concepts of devops.

Continuous Integration (CI):

At its core, CI is a development practice that emphasizes merging code changes into a shared repository multiple times a day. This approach promotes the early detection of integration issues, reducing the chances of conflicts and bugs during the development process. The CI process involves the following key steps:

Code Commit:
Developers commit their code changes to a shared version control system like Git.

Automated Build: An automated build process compiles the code and creates executable artifacts.

Automated Testing: A suite of automated tests, including unit, integration, and regression tests, is executed to ensure code quality and functionality.

Immediate Feedback: Developers receive prompt feedback on their code changes, allowing them to address issues quickly.

Early Bug Detection: Integration issues and bugs are caught early in the development cycle, minimizing the impact on the project timeline.
Benefits of CI:

Faster Development Cycles:
With automated testing and continuous feedback, developers can iterate and release software faster.
Reduced Integration Risks: Frequent integration reduces the likelihood of large-scale integration problems and conflicts.
Code Quality Improvement:
Automated tests enforce code quality standards and help catch regressions.
Enhanced Collaboration:
Developers collaborate more effectively as they work on a shared codebase.

Continuous Deployment (CD):

Building upon the foundation of CI, CD takes the development process one step further by automating the deployment of code changes to production environments. CD ensures that validated and tested code is automatically deployed to production with minimal manual intervention. The CD process includes:

Automated Deployment Pipeline:
A series of automated stages, including testing, security checks, and deployment, are defined in a deployment pipeline.

Automated Testing: Extensive testing, including load, performance, and security tests, is performed to ensure that the application is production-ready.
Approval Gates: Automated checks and manual approvals ensure that only validated code moves through the pipeline.
Production Deployment:
Once the code passes all stages, it's automatically deployed to the production environment.
Benefits of CD:

Faster Time-to-Market:
Automation reduces the time it takes to deploy new features and updates to users.
Consistency and Reliability:
Automated deployments minimize the risk of human error and ensure consistency across environments.
Rapid Feedback Loop: Immediate deployment of validated code allows for quick feedback from users and stakeholders.

Reduced Downtime: Incremental and automated updates reduce downtime during deployment.
Conclusion:
Continuous Integration and Continuous Deployment are not just buzzwords; they are transformative practices that reshape how software is developed and delivered. By automating processes, catching bugs early, and accelerating deployment, CI/CD accelerates innovation and improves the overall quality of software. Adopting these practices aligns with the DevOps ethos of collaboration, efficiency, and delivering value to users consistently. In the dynamic landscape of software development, mastering CI/CD is a crucial step towards staying competitive and agile.