DEV Community: John Rommel P. Octaviano

Welcoming Everyone to the World of Computer Science

John Rommel P. Octaviano — Wed, 07 Feb 2024 02:33:14 +0000

In the vast and ever-evolving realm of computer science, diversity is not just a buzzword; it's a world of innovation, creativity, and progress. Yet, for many, the image of a stereotypical "computer scientist" remains fixed: a solitary person hunched over a keyboard, lost in lines of code, disconnected from the world around them (not having a social life)

But the reality is far richer and more different than this common portrayal suggests. Computer science is a vibrant tapestry woven from the diverse threads of people from all walks of life regardless of their backgrounds and cultures. From developers to designers, analysts to entrepreneurs, the field thrives on the unique perspectives and experiences each individual brings to the table.

At its core, computer science is about problem-solving, creativity, and collaboration. It's basically about using the power of technology to address real-world challenges, from healthcare and education to sustainability and social justice. And to truly unlock the full potential of technology, we must ensure that everyone, regardless of race, gender, ethnicity, or socioeconomic status, is belong in this wide universe.

Creating a more inclusive and welcoming environment in the world of computer science is crucial for making it all possible in a long shot.

Educating Everyone
Access to quality education is the first step towards this process. We must work to eliminate barriers to entry and provide equal opportunities for learning computer science for everyone, starting from an early age. This means investing and exposing in diverse educational programs, offering scholarships and mentorship opportunities, and fostering a learning culture for the long term.

Initiatives and Representation
It's essential for individuals from underrepresented group of people to see themselves reflected in the field. By highlighting diverse role models and celebrating their achievements, we can inspire the next generation of beginners and break down stereotypes.

Safe and Learning Spaces
Building inclusive communities where everyone feels valued and respected is essential. This requires actively combating discrimination, harassment, and bias in all its forms as being a hindrance. By fostering a culture of empathy and understanding, we can create environments where everyone feels welcome to contribute their unique ideas.

Collaboration and Mentorship
Mentorship can play a significant role in supporting beginners from different groups and helping them navigate the complexities of this vast field. By catering mentorship programs and creating opportunities for collaboration, we can empower aspiring computer scientists to succeed and thrive in a pace where they are safe and valued.

Continued Advocacy and Action
Building a more inclusive and equitable computer science community is an ongoing process that requires sustained effort and commitment for the sake of volunteerism. We must continue to advocate for diversity, equity, and inclusion at all levels.

By welcoming everyone to the world of computer science, we can tap into a wealth of talent, creativity, and innovation. Together, let's build a future where technology truly serves the needs of all people, regardless of who they are or where they come from. Being free for everyone.

Join us on this journey of discovery, collaboration, and empowerment. Together, we can shape a more inclusive and equitable future for computer science and beyond.

Demystifying Programming Fundamentals: Variables, Operators, Control Structures

John Rommel P. Octaviano — Fri, 04 Nov 2022 12:15:00 +0000

Prologue
Foreword
Variables
Constants
Identifiers
Data Types
Simple (Primitive) and Composite (Reference)
Operators
Arithmetic
Logical
Relational
Assignment
Increment/Decrement
Control Structures
Selection
Repetition
Epilogue

Prologue

In my experience, I learned that skipping the basics and proceeding all along to the application of certain technologies (such as programming language) to create something that could make sense is hard.

Missing the basics also could lead to a lack of foundation which is a building block of intermediate to advanced concepts. Sure, learning by doing is great for some people but skipping the starting notions in order to start something out is also an important thing worth looking at.

In this part, I will talk about the core concepts of programming. That is what are variables alongside their data types, different types of operators in programming, kinds of structures crucial for grouping our source code, and other basics.

I will share fundamental concepts of programming by making them simple and concise over the hood just to make things more brain-friendly.

These are the fundamental building blocks that must give emphasized first to everyone who is just getting started on learning how to code. And without further ado, let's get started.

Foreword

This material is not a stand-alone reading to learn about the fundamentals of programming as a whole. It is a simplified blog that tackles the basics. It could be used as a primary or secondary reference for learning them but it's not a stand-alone one.

You could use this with other means of learning such as watching a video, reading other articles, etc. It's good to be supplemented with third-party references. You can also use this to have a quick read about concepts in relatively simplified content.

If you are just starting out, it really doesn't matter to learn all the internal happenings about specific concepts. What really matters is that we know their use cases and we know at least how their work. It's not necessary to immediately learn their total workings in the background.

But if you want, you can explore them on your own as there are tons of references on the web to make your hands dirty with it if you want to play with it. After all, we are different types of learners and nothing's wrong with that.

Studying the fundamentals of programming is also not language-specific. In fact, it is a general concept which means that we can use other programming languages out there when learning it. I suggest you pick those languages that are very popular in the tech industry such as Java, Python, JavaScipt, Rust, Go, etc.

These languages are well-established ones that also have a bright future on top of them. In regards to their setup and installation to get started on your computer, the web is full of tutorials on these. Feel free to search them out to get your hands dirty in no time.

Variables

What the heck are these variables and why they are important in programming? Variables in programming and in mathematics are similar. They basically just store a value that could be used for different crucial operations.

But unlike in mathematics, variables could store not just numbers. They could be characters, series of characters (or called strings in programming), booleans (just only true or false), and any other thing that could be stored for further operations.

Variables could also store references to a specific thing or entity in programming. Such references mean that variables hold the entity's information crucial for accessing them. Values are also called literal or just simply data in some contexts.

Under the hood, it's also important to note that variable values are stored in the memory of a computer they are running from just like other things in programming.

Simple variable declarations in Python

myFullName = "John Rommel Octaviano"  
myMiddleInitial = 'P';  
myAge = 20;  
isHuman = true;

Accessing or reading the values that a variable stored could be used for different operations such as multiplication and division if the said value is a number. The same goes for strings.

We can do string manipulation (or just basically modification) like converting them to uppercase. Storing values in a variable is one of the often practices that we must fully and properly be utilizing of. Storing and retrieving values should also use moderately.

In some instances, the usage of variables is not necessary at all. In fact, we can still do some operations to do our aimed task. But variables make these operations much easier by reducing repetitions like duplicating code.

Variables are also crucial in operations where values need to be stored in order to achieve a specific operation to keep track of something which then the result of it that is stored in that variable and is also to be used for further operations, and so on.

A source code for solving the roots of a quadratic equation that shows the importance of variables in storing values in such small use cases

double a;  
double b;  
double c;  
double determinant;  
double root1;  
double root2;  

a = 2.3;  
b = 4;  
c = 5.6;  
determinant = b * b - 4 * a * c;  

if (determinant > 0) {  
  root1 = (-b + Math.sqrt(determinant)) / (2 * a);  
  root2 = (-b - Math.sqrt(determinant)) / (2 * a);  
} else if (determinant == 0) {  
  root1 = root2 = -b / (2 * a);  
} else {  
  double real = -b / (2 * a);  
  double imaginary = Math.sqrt(-determinant) / (2 * a);  
}

Constants

Constants are just special types of variables that cannot be updated or prohibited from changing once we declared them. Since these variables cannot be changed, operators like Assignments and Increment/Decrement will not work, and using them with constants could lead to errors.

They are only available for reading or accessing their value for specific purposes. It's also just a programming representation of absolute variables in Math like the Pi, Golden ratio, Euler's number, and many more.

Identifiers

Identifiers are just another term for the name of something in our code. In programming, most concepts like variables, functions, objects, arrays, and others are needed to become known by putting names.

Such names that we created are used for their references and specific purposes when we need to interact with them like creating, reading, and updating their values.

Conventionally, identifiers must become readable like putting a concise name in relation to their value. They must also a valid by following a specific language's official syntax just like not using a reserved keyword.

I highly suggest that we must check the language syntax for creating identifiers when creating one to avoid errors. Conventions like PascalCase, camelCase, and kebab-case are the most commons to use.

Data Types

Since variables could store values like strings, numbers, and booleans, these variables could also be regulated on what type of data or literal they could store. In static languages like Java & C#, stating data types in variables is highly enforced upon declaration. Not doing so could cause exceptions.

Simple statements using C# that declare variables with data types

string myFullName = "John Rommel Octaviano";  
char myMiddleInitial = 'P';  
int myAge = 20;  
bool isHuman = true;

On the side of dynamic languages like JavaScript and Python, stating data types are not necessary. The compiler (or basically just an application that converts our code into a series of 0s and 1s that only our CPU understands to execute our desired operations) is not enforcing these kinds of declarations (or basically just creating but not storing anything).

Simple statements using Python that declare variables without data types

myFullName = "John Rommel Octaviano"  
myMiddleInitial = 'P'  
myAge = 28  
isHuman = true

Just think of data types like just a marking that states that a particular variable could only accept a value depending on the data type that is stated. Not following these markings by means of not storing a number in a String could cause errors. A protocol must be followed.

int - for integers of the whole number

float - for numbers that have a floating point value

double - for numbers that have floating point value in which the range or limit of this data type that a variable can accept is much higher than the float

long - for integers of the whole number in which the range or limit of this data type that a variable can accept is much higher than int

char - for a single character

String - for the sequence of characters

boolean - for values true or false

Simple statements using Java that declare variables with data types

String myFullName = "John Rommel Octaviano";
char myMiddleInitial = 'P';
int myAge = 20;
float myBatteryLevel = 90;
double myTemperature = 35.7;
long myCellCount = 30,000,000,000,000;
boolean isHuman = true;

and many more. These are the common and general types that most programming languages present particularly the strongly-ones. There are also data types for specific entities like arrays (basic storage for values), and many more.

In fact, we could also create our own types (this is called Generics in programming, an advanced concept).

Simple (Primitive) and Composite (Reference)

Variables have also kinds of their own. It could be simple or composite. A variable could be considered as simple if the data type that is used to create or declare it is using built-in data types. Those are types that are naturally provided by the language itself.

Simple types are also called primitives which used primitive data types of a specific language. Basically, they directly stored the actual value. In which, a simple or primitive variable literally represents the actual literal itself.

Meanwhile, composite ones are basically just the complete opposite. Those are the variables that used created types by the programmer itself. In most languages, we can create our own types. They are also called reference types.

Reference variables commonly do not directly store the actual value itself but the reference or just basically a piece of information of the actual value's location in the memory.

It's a kind of intermediate topic but as your progress succeeds, you will know more about them and their importance in writing code.

Operators

Storing different values and literal is good. But we need to do something about them in order to consume or use them depending on the specific use case that we aim for. Good thing is, just like in Mathematics, there are operators.

Fundamental operators in mathematics and some programming operators shared concepts between them.

These are the general operators which are generally common across different PLs (programming languages) out there. Some operators could also mean different in other language syntaxes for unique operations. They are also part of their own unique features.

Arithmetic

Addition operator (+)
add number types. It could also be used to concatenate (or just basically just combine) non-string types to string types in most languages.

Subtraction operator (Subtract) (-)
subtract number types. It could also use to indicate negative numerical.

Multiplication operator (*)
multiply number types.

Division operator (/)
divide number types.

Modulo operator (%)
it computes the remainder of the number types.

Simple statements using JavaScript that perform different basic computations and store their values on different variables

let numOne = 23;  
let numTwo = 24;  
let sum;  
let difference;  
let product;  
let quotient;  
let remainder;  

sum = numOne + numTwo; // 47
difference = numOne - numTwo; // -1
product = numOne * numTwo; // 552
quotient = numOne / numTwo; // 0.95833333333
remainder = numOne % numTwo; // 0

Logical

AND (&&)
returns true if both the conditions on the left and right are true

OR (||)
returns true if at least one condition on either left or right is true

NOT (!)
flips the boolean value of a condition or a value

Simple statements using Java that perform different basic operations by using logical operators between 2 boolean values and printing their results

boolean booleanOne = true;  
boolean booleanTwo = false;  

System.out.println(booleanOne && booleanTwo); // false  
System.out.println(booleanOne || booleanTwo); // true  
System.out.println(!booleanOne); // false  
System.out.println(!booleanTwo); // true

Relational

Equals to (==)
returns true if both condition or value are equal

Not equals to (!=)
returns true if both condition or value are not equal

Greater than (>)
returns true if the value on the left is bigger than the right

Less than (<)
returns true if the value on the left is smaller than the right

Greater than or equal to (>=)
returns true if the value on the left is bigger than or equal to the right

Less than or equal to (<=)
returns true if the value on the left is smaller than or equal to the right

Simple statements using Python that perform different basic comparisons of numbers by using relational operators between integer numbers and printing their results

numOne = 56
numTwo = 33

print(numOne > numTwo) # True
print(numOne != numTwo) # True
print(numOne > numTwo) # True
print(numOne < numTwo) # False
print(numOne >= numTwo) # True
print(numOne <= numTwo) # False

Assignment

Assignment (=)
assigns the value of the right variable to the left variable

Add and assign (+=)
increase by adding the value of the left variable from the right variable

Subtract and assign (-=)
decrease by adding the value of the left variable from the right variable

Multiply and assign (*=)
increase by multiplying the value of the left variable by the right variable

Divide and assign (/=)
decrease by dividing the value of the left variable from the right variable

Simple statements using C++ that perform different basic comparisons of a number by using assignment operators and printing its final result

int numOne = 28;

numOne += 5; // 33
numOne -= 4; // 29
numOne *= 7; // 203
numOne /= 2; // 101

cout << numOne; // 101

Increment/Decrement

Post-increment (x++)
increase the value of the variable by 1 after using the value

Pre-increment (++x)
increase the value of the variable by 1 before using the value

Post-decrement (x--)
decrease the value of the variable by 1 after using the value

Pre-increment (--x)
decrease the value of the variable by 1 before using the value

Simple statements using Java that perform different basic modifications of a number by using increment/decrement operators and printing its final result

int numOne = 28;

numOne++; // 28
++numOne; // 30
numOne--; // 30
--numOne; // 28

System.out.println(numOne); // 28

Control Structures

Writing code with operators and variables is relativity good enough for selected operations. But most of the time, we need additional tools to meet certain functionalities that our app needs. We need more tools to perform tasks that can do the heavy lifting for us in meeting our specific needs in code.

And this is where control structures in programming came to work. They are crucial and not just optional tools to consider. Just like operators, there are structures that are not present in one language and that is part of learning some adjustments when jumping from one language to another.

But, the good thing is there are general structures that most languages are common for.

Selection

Serves as a gate on what code will be run. Since it's like a gate, the only way to open them is to have a true key, literally. Or a condition evaluates to TRUE.

Single Alternative (if)

Statements will be done or executed when a condition is met, evaluated, or equal to TRUE. Otherwise, meaning if the condition will become equal to FALSE, then nothing happens.

An if statement checks if the value of a variable is equal to something through a conditional in JavaScript, in which if the checking is true, it will print something, otherwise, nothing happens

let foo = "foo";  

if(foo === "foo") {  
  console.log("foo!"); // Prints this if true
}

Double Alternatives (if-else)

Statements will be done or executed when a condition is met, evaluated, or equal to TRUE. Otherwise, meaning if the condition will become equal to FALSE, then the alternative statements will be executed.

An if statement checks if the value of a variable is equal to something through a conditional in JavaScript, in which if the checking is true, it will print something, otherwise, it prints something else

let foo = "foo";  

if(foo === "foo") {  
  console.log("foo!"); // Prints this if true
} else {  
  console.log("bar!"); // Prints this if false instead
}

Multiple Alternatives (if-elseif-else)

Statements will be done or executed when a condition is met, evaluated, or equal to TRUE. But, if the condition returns FALSE, succeeding conditions will be checked until a condition is evaluated to TRUE, and statements inside of that will be executed. Finally, if all those succeeding conditions are all evaluated to FALSE, meaning none of them happens, then the statements in the final block will be executed.

An if statement checks if the value of a variable is equal to something through a conditional in JavaScript, in which if the checking on the first condition is true, it will print something, otherwise, it will check the next conditions and print something else if true but if all conditions are false, print the last one

if(foo === "bar") {  
  console.log("bar!"); // Prints this if true
} else if(foo === "foobar") {  
  console.log("foobar!"); // Prints this if false instead
} else {  
  console.log("foo!"); // Prints this if everything else is false
}

Repetition

Serves as a wheel that continues to spin or run our code repeatedly. Since it's like a wheel, the only way to stop them is to have a false handbrake, literally. Or until a condition returns FALSE.

Repeat-While (while)

Before statements will be run, a condition is first evaluated and if the result is equal to TRUE, code will be run. After the execution, it will back at checking the condition again and it will run again and again until the condition becomes FALSE.

A basic while loop in Java that prints all numbers within the starting and ending range

int counter = 1;  

while (counter <= 10) {  
  System.out.println(counter);  
  counter++;  
}

Do-Repeat-While (do-while)

Statements will be run first before checking the condition. After checking and the result was TRUE, it will run again the code and back at checking again. It will run again and again until the condition becomes FALSE. Unlike while loops, do-whiles are expected to run at least once.

A basic do-while loop in Java that prints all numbers within the starting and ending range

do {  
  System.out.println(counter);  
  counter++;  
} while(counter <= 10);

Repeat-For (for)

This structure also works under the hood like while loop but they have their own major difference. In for loop, iteration or number of times the code will run is known before the execution while the iteration is not known in a while loop.

The code in here will run on a known time while the while loop is not. The other differences are most commonly language specific.

A basic for loop in Java that prints all numbers within the starting and ending range

for(int counter = 1; counter <= 10; counter++) {  
  System.out.println(counter);  
}

Epilogue

And there you have it. That's some of the different concepts of programming categorized as fundamental. We tackled variables alongside what constants, and identifiers are, alongside data types and their subtypes for basically just storing variables. We also learned more about different operators from arithmetic to increments and decrements to solve create calculations and execute crucial tasks. Lastly, we also talked about different control structures that make our applications much more smarter.

I hope you learn more about the basics of programming. Now, you have at least basic ideas about some general concepts in relation to programming at least in simple terms. Concepts that are fundamentally crucial in making real-world applications. Feel free to learn more about them as your progress grow. Thank you and see you at the next one.

Recipes tell you nothing. Learning techniques is the key.

Tom Colicchio

Demystifying Programming Fundamentals: Languages, Syntax, Statements

John Rommel P. Octaviano — Thu, 03 Nov 2022 10:06:13 +0000

Prologue
Foreword
Language Types
Level
Typed
Syntax
Reserved Keywords
Statements and Expressions
Blocks
Conditions
Comments
Epilogue

Prologue

Learning how to code properly is a vital means of grasping at least the basic fundamentals of programming. Programming is hard especially when the learning habits and experience are also bad. One's journey makes it harder which leads to different issues in making our own source code.

Changing the way we do programming also involves a proper learning habit that we should enforce and adapt.

In this part, I will talk about the different types of programming languages alongside syntax with reserved keywords, and statements. I will tackle each one of the general and high-level concepts which are also mainly present in most programming languages out there.

Learning these concepts makes programming easier as they are fundamentally attached altogether to solving problems by making applications to create solutions. Learning every single one of them could also lead to an easier learning experience in multiple programming languages out there. One of the ways in order to make programming easier to study is to make our hands dirty which, sadly, some people are missing.

Foreword

Language Types

Before we proceed to learn the fundamentals, let's talk about types of programming languages and why at least having a basic understanding of their difference could help us understand more about programming.

There are a lot of programming languages out there and most of them are open-source meaning they are open for the public for modification and usage.

Most of them, in terms of structure, are somewhat similar to each other and there's a chance that we will have to interact in not just one language so having basic knowledge about at least basic distinguishable features that they have is worth learning about.

Level

In terms of level, languages could be classified as either high or low-level one. What doesn't it mean? Well, the word level here is not just about the difficulty of the learning curve to get started or its usage of it. It is also not just about its superiority over the low-level ones.

Levels, in the context of PLs (or programming languages), point to how the syntax, which I will gonna talk about in a moment, is readable or understandable to human programmers. This means that not all languages are readable to us, at least at first glimpse.

Also, the levels describe the background operations a language will take to create or to do an operation commanded by us. This also means the levels describe the amount of abstraction (or basically just means simplicity or complexity) a language provides, generally speaking.

Both these languages have their own pros and cons and we must consider them into account. Mostly, in terms of levels, they are classified into two: high-level and low-level.

High

High-level programming languages are considered high due to valuable reasons. High-level languages have their code consisting of English words called keywords which makes them more readable to us and coding with them just like similar to how to write poems - line by line.

These languages, in terms of their background execution, are much simpler than the low levels.

With this regard, we can conclude that coding with this type is much simpler and faster. Writing a bunch of solutions is straightforward since the words that need to use are intuitive.

Generally, it provides a high level of abstraction which aims to lessen the difficulty of creating solutions through PLs. The code base of these PLs is easy to maintain or sustain, debug, refactor, and many other modifications.

PLs of this category are independent of the machine that the code is running from and the focus is only to create source code to solve problems without the emphasis on whether the machine will run it or not. Notable examples are Java, C++, C#, JavaScript, Python, Rust, and many more.

Simple statement using Java that displays something on the screen

String greeting = "Hello, World.";

// Prints "Hello, World."
System.out.println(greeting);

Compilers and interpreters are applications that convert our high-level code into a machine or binary code that CPUs only understand to do a specific task based on the instructions that we've made. They are a middleman whose task is to just translate our code into a series of 0s and 1s. They are specifically crafted in order to do this task to be thrown to our CPU.

In terms of their difference, interpreters convert our code into machine code right when our program or application runs also known as runtime while compilers translates our code into machine code before our program or application runs also known as compile time. Interpreters are used by dynamically-typed PLs while the compilers are used by static types which we will talk about in the next part.

Low

Low-level programming languages are considered as low due to underlying reasons. Aside from these PLs being the first ones who exist in the early days of computers, the syntax of these languages is highly similar to computer commands.

The background execution of these PLs is also specific and relies on the machine that it is running from which could be simple or complex.

Coding with this level is relatively much more difficult and somewhat time-consuming due to their early implementations. Creating a source code needs to be clarified carefully because aside from they are not that understandable at first, they are specific to their machine.

Generally, the level of abstraction it has are low which makes them albeit complex to use.

The speed and efficiency are one of its great strengths as they directly communicate to the CPU to execute instantly the created code without making any other additional background executions which also makes them for being memory-efficient.

They are also highly controllable for maximizing performance to unlock their powerful potential. Notable examples are Assembly, the machine code itself, and others.

Simple statement using Assembly that displays something on the screen

org 0x100  

mov dx, msg  
mov cx, len  
mov bx, 1  
mov ah, 0x40  
int 0x21  

mov ah, 0x4c  
int 0x21  

msg db 'Hello, World.', 0x0d, 0x0a  
len equ $ - msg

Typed

Generally, programming languages could classify as being statically or dynamically typed. It also generally refers to the necessity of stating data types, alongside variables which we will talk about in a second. Both of these types of languages have their own pros and cons.

That doesn't mean static languages are strict in terms of syntax doesn't mean they are superior compared to dynamic ones and vice versa.

After all, programming languages are just part of the numerous tools to create solutions like applications and it's really up to a programmer (us) how to pick a tool or technology like languages to solve problems suitably.

Dynamic

Dynamically-typed languages are considered loose or flexible because stating data types is not required by their own compilers. This also means that types are only known or recognized as the program or application is running or in runtime.

They are made to have the capability of recognizing these types upon execution that skips, ignores, or completely disregards the so-called type-checking (or basically just a way of a language to check the types and values).

The PLs of this type promote flexibility and freedom in their code as they allow us to have complete control of the source code that we are writing.

Simple statement using C++ that declares variables with data types

string myFullName = "John Rommel Octaviano";  
char myMiddleInitial = 'P';  
int myAge = 28;  
bool isHuman = true;

Static

Statically-typed languages are considered strong or strict because they tend to require us to state data types on pretty much anything that they are required by their own compilers. This also means that those types are known or recognized before the program or application will run or in compile time.

This is to ensure the correct usage of types in the source code wherever they are needed. They enforce the type-checking and throw errors wherever they encounter inappropriate use-case.

This makes PLs of this type produce a robust code that has a uniform standard of using types in a relatively appropriate manner.

Simple statement using JavaScript that declares variables without data types

let myFullName = "John Rommel Octaviano";  
let myMiddleInitial = 'P';  
let myAge = 28;  
let isHuman = true;

Syntax

Syntax is defined as the arrangement of words and phrases to create well-formed sentences in a language. Well, it makes sense because in programming, writing every piece of code must follow the said syntax of a specific language that we code along.

Not following so mostly will cause exceptions (or basically just another term for errors).

Generally, most languages have their own implementation or defined rules on how to write code based on its structure or contents implemented by their creators.

As programmers, one of our jobs is to write code that follows proper syntax in order to do something through that language. Learning the syntax is language-specific and as we learn more concepts of a language that we code from, the more we have exposed to the different syntax that it supports.

It's progress-based learning you could say.

We need to also ensure reading language official documentation or by just simply researching online about a particular syntax.

The good thing though is that when we are using a well-built IDE or code editor, they have the capability of visualizing incorrect syntaxes that we wrote in which could help us to fix them in a much faster and smart manner.

Generally, the syntax of a particular language is somewhat similar to another one. As we learn more other programming languages, the more we notice that the syntaxes are very similar to each other (at least to most languages that are considered high-level ones).

Just like for example, the syntax of JavaScript and C# is heavily-inspired by the syntax of C and C++. A concept could also be present in a particular language to others ones.

Different syntaxes for creating just a basic variable for dynamic type and static type languages and sample syntax for creating general structures

<declaration type> <name> = <value>;  

<data type> <name> = <value>;  

if (condition) {  
    <statements>  
}  

for(<initialization>; <condition>; <initialization modification>) {  
    <statements>  
}

Note

Lastly, when learning the fundamentals of programming, it's also important to note that even though the concepts themselves are not particular to a specific language, meaning it is a general concept most likely applied to the majority of PLs, the syntax on the other hand may vary.

It's important to specifically check the official syntaxes to avoid nasty errors. The web has a very plenty amount of resources so kindly check them out to learn more about a particular language.

Reserved Keywords

Most programming languages have their own syntaxes represented through the use of English words like for, do, while, if, else, switch, break, continue, and many more. These are called reserved keywords and they are mostly not allowed to be used in user-specific use cases such as naming something, etc.

They are reserved and specifically intended for special use cases. Only use them in particular use cases where they are needed.

A basic use case that shows that these reserved keywords have unique purposes in a particular language like JavaScript

let foo = 'Mamba';  
let bar = 'Coco';  

if (foo === bar)  
console.log('They are both equal!');  
else  
console.log('They are not equal!');  

for (let i = 0; i <= 9; i++) {  
console.log(`${foo} & ${bar}!`);  
}

Note

One important notion to remember is that doesn't mean a language shared a syntax with another language generally means they are completely similar to each other as a whole. There is still some difference between them such as concepts that are not present in one another.

They are generally the same but not at all. All language has their own unique features and we also need to learn those principles in order to grasp them.

The good thing is once we grasp the general principles just like learning the fundamentals itself, adapting to learn other languages became easier and we only need to adjust to those distinct concepts that are present in them.

Statements and Expressions

Statements are just pieces of code that comprehend specific instructions or tasks that we want to accomplish. They're not producing a value on their own, unlike expressions. They are the pieces of code that hold our entire program together and they provide some sort of slots to be filled by expressions

Expressions on the other hand produce values. Values whether a product of an operation like adding numbers or just a raw value like a number. They fill the so-called slots produced by statements.

They work hand in hand together as part of an entire program or application in order to run. Together, they both formed the big picture of our intended product or solution.

Basic addition operation as an example of the combination of statements and expressions using Java

int numOne = 43;  
int numTwo = 45;  
int sum = 0;  

sum = numOne + numTwo;

Blocks

They are basically just multiple pieces of statements and expressions grouped or enclosed together, commonly by curly braces to do something. They are just multiple lines of code inside these braces to do tasks. Nothing special. Just a grouped source code and that's what a block or code block is.

Forming single lines or multiple lines together forms and isolating them through braces forms it. They are found and used mostly in other programming fundamentals like structures. They are part of their syntax in most PLs.

Basic code that determines if the entered year by the user is a leap year or not using C++

int year;  

cout << "Enter a year: ";  
cin >> year;  

if (year % 400 == 0) {  
cout << year << " is a leap year.";  
}  
else if (year % 100 == 0) {  
cout << year << " is not a leap year.";  
}  
else if (year % 4 == 0) {  
cout << year << " is a leap year.";  
}  
else {  
cout << year << " is not a leap year.";  
}  

return 0;

Conditions

Conditions in real-life and conditions in programming both work the same way. They are statements that produce expressions that make our computer decide whether they return only 2 types of values - true or false. Depending on the returned value, succeeding tasks are gonna be executed aligned to them.

Just think of true or false as yes or no as responses originated from these conditions. This is a way to make computers create decisions based on specific conditions that we created.

And through that decisions, they will do intended tasks according to the results of their decision, which are commonly based on either true or false which makes our programs more dynamic and concise.

Conditions are used in so-called structures, which is a concept in programming to do more tasks. They are some sort of machine that creates raw materials to be consumed by other machines like structures for other intended tasks.

Pieces of code to show the use case of conditions

if (foo == bar)...  

while(foo == bar)...  

for(int i = 0; foo <= bar; i++)...

Comments

Comments are just texts whose purpose is to basically describe something in our code. Whether explaining something about the value of a variable or indicating the purpose of something, comments should be used moderately.

Their sole purpose is to make our source code easier to read and understand to reduce the difficulty of maintaining or modifying them.

Generally, because of their syntax, they are commonly ignored by compilers or interpreters. We can comment on everything in code like our statements themselves but be mindful of commenting on something to avoid errors.

Code using Python that solves quadratic equations

# Solve the quadratic equation ax**2 + bx + c = 0

# import complex math module
import cmath

a = 1
b = 5
c = 6

# calculate the discriminant
d = (b**2) - (4*a*c)

# find two solutions
sol1 = (-b-cmath.sqrt(d))/(2*a)
sol2 = (-b+cmath.sqrt(d))/(2*a)

# displays the result
print('The solution are {0} and {1}'.format(sol1,sol2))

Epilogue

And that's it. That's the different types of programming languages alongside what syntax is and reserved keywords. We tackle PL types based on their level which is not basically all about their difficulty. We also tackled their strictness and conciseness as they distinguishable features. Also, we tackled what syntax is and the reserved keywords in a language.

I hope you learned something from this article. Now, you have at least basic ideas about some general ideas in relation to programming in a nutshell. Underlying concepts that matter not just only when starting out but also in the long run. Hopefully, you grow on this blog and continue to learn about them. Thank you and see you at the next one.

Change is the end result of all true learning.

Leo Buscaglia

Assessing Personal Career and Progress

John Rommel P. Octaviano — Wed, 02 Nov 2022 10:25:00 +0000

Prologue
Ways
Taking Notes
Seeking Assistance From Other People
Research
Epilogue

Prologue

In my own experience, taking a pause from something that we do in order to keep track of something that is needed some attention is very important especially if we tend to experience a not-so-good piece of mind.

But, before we start on technical things and stuff, let's pave the way to considering ourselves first. Let's say hello to ourselves before we proceed on the long journey of Computer Science. Or in the IT field as a whole. Am I good? Can I still do it? Do I need some rest? It's a highly subjective process but you get the idea. Let's assess our personal life first.

Before we start doing something, let's check ourselves first. Just like checking a car before going on somewhere. The different parts of the car must be safe before traveling, especially if the destination is far away.

Check mental health. But, take it easy. This is unskippable. Do I need to rest? Am I tired? Do I need someone to enlighten me on this vast field of a profession? What things do I need to consider?

Giving ourselves time to take a stop and assess our life is a crucial process to help us start some personal directions before starting out or continuing something. Some of us have our own battles and silent wars to fight, which most don't know about. And taking a little time to have a bird's eye view of what's happening in our lives is beneficial most of the time.

It could give us an idea of where we are lacking. It could give us a fact about what's going on in our life. It also could give us a different perspective on our strengths and weaknesses, ups and downs, improvements and lapses, etc. Different possibilities. Regardless of whether we can accumulate positive or negative after taking this step, it is what it is and that's a win.

Ways

Taking Notes

How can we do it? Well, it depends on our own preferences. I recommend that we try to list our own personal positives and negatives. About the positives, try to analyze what their future is. Do I need to leave them behind? Do I need to pursue it? The same goes for the negatives. Also include the solutions of what should happen to them sometime in the future.

We can grow in doing this process as we make ourselves up to keep track of important points in our life that we should consider as we are on the way to building our careers. And as time goes by, we must always have room for improvement is very vital especially since our field is aligned with technology.

Also, taking notes is very crucial because our notes are the extension of our brain which is one of the important things I learned on my personal coding journey. The truth is, when we train ourselves to take notes over time, it will help us along in our process of learning how to code as a whole. The more we take notes, the more the knowledge could stick better on the back of our heads.

So, if we want to assess our personal career and progress? Taking notes is one of the best and easiest things to do here.

Seeking Assistance From Other People

If we're in a relationship, have a circle of friends, or relatives have a dog that could talk, seeking assistance from them is also important. Why? Because you or we have a different POV about ourselves. More POVs, means more factors to consider and review. More perspective could also mean more possibilities. Who knows?

We can also ask for help on how to plan and assess our life. The truth is, no man is an island. Yes, sometimes. So, we must grab the privilege that we have to make up for these things. In this way, we learn how to socialize and communicate better with other people. Which is important in the IT industry as a whole. Communication and socialization are very crucial. Let's normalize these things. Very important in one's career.

BTW, if we have professional peeps that are known such as personal doctors like Psychiatrists, Software engineers, etc., seeking pieces of advice from them is also helpful.

Research

Lastly, research. And research. And research. Just like training to always take notes, we should also train ourselves to always browse the web through a search engine like Google. In fact, Googling is a skill. Solving a particular problem through means of using specific keywords to find a solution is a skill. Let's normalize that. A very crucial skill that could place us in a better place in the long run in our future careers.

In fact, aside from the other 2, this is also an unskippable part as solving a particular problem involves seeking possible and justifiable solutions just like what we learn from Science.

Now, here's the thing. Researching every aspect that is unknown to us while assessing our life could really help us. Searching other people's stories to build their careers to success, browsing some great testimonials from them, and being inspired by their personal experiences could leverage the assessment of our career.

Be inspired and motivated by their stories. There are a bunch of successful stories in tech. They also share their personal struggles and how they overcome them. A college dropout before, now a professional software engineer. A former nurse turned data scientist. Engineering major turned mobile developer. There are a bunch of these kinds of stories.

Also, there are many professional recommendations by professionals. Just kindly check them out. The testimonials from those kinds of people are also different.

But know the limits. Don't compare ourselves to them. Being inspired and imitating someone are two distinct qualities. Always remember that everyone's journey is totally different from others (even though we always hear this thing every single damn time). Just don't compare ourselves to others. It's one of the root causes of human negativities.

And yes, you got the idea. Just research all along. Let's use the free privilege that we have. Search engines are free. So, why not?

Epilogue

And that's it. Assessing our life is crucial as we start and build careers in tech. Considering also our mental health is a very significant part of this life-long career. Also, we have also tackled the ways how we can do it. Maybe, we have other ways or methodologies which are good. We can just combine it all along. It is somewhat highly subjective.

I just want to tell everyone that assessing one's personal life should be a priority and unskippable. I also introduced some ways how to do it. We can use these ways and combine them with our own ways. We can just grow in these ways and then as time goes by, it is possible to increase. But for the most part, these are things that are highly suggested which other professional folks could also suggest. These are just things that worked for me.

Just for the sake of clearing our minds filled with doubts and worries, please, take time to assess. Take time to reflect. Take time to find out the state of our life at least once. I hope (if not all), these pieces of advice could help and contribute at least a little. To set as motivation and inspiration to continue for the better.

The biggest room in the world is the room for improvement.

Helmut Schmidt

DEV Community: John Rommel P. Octaviano

Welcoming Everyone to the World of Computer Science

Demystifying Programming Fundamentals: Variables, Operators, Control Structures

Table of Contents

Prologue

Foreword

Variables

Constants

Identifiers

Data Types

Simple (Primitive) and Composite (Reference)

Operators

Arithmetic

Logical

Relational

Assignment

Increment/Decrement

Control Structures

Selection

Repetition

Epilogue

Recipes tell you nothing. Learning techniques is the key.

Demystifying Programming Fundamentals: Languages, Syntax, Statements

Table of Contents

Prologue

Foreword

Language Types

Level

High

Low

Typed

Dynamic

Static

Syntax

Note

Reserved Keywords

Note

Statements and Expressions

Blocks

Conditions

Comments

Epilogue

Change is the end result of all true learning.

Assessing Personal Career and Progress

Table of Contents

Prologue

Ways

Taking Notes

Seeking Assistance From Other People

Research

Epilogue

The biggest room in the world is the room for improvement.