DEV Community: Valentiina VP

Te invito a mi canal de youtube

Valentiina VP — Thu, 04 Mar 2021 22:05:32 +0000

Si tu idioma nativo es el español y deseas aprender sobre programación, te invito a mi canal de Youtube donde comparto contenido en Español sobre este maravilloso mundo.

Aquí estaré añadiendo los enlaces a los vídeos que voy subiendo, ¡por si deseas aprender connmigo!

Mañana 5 de Marzo comenzaré la misma serie que estoy llevando aquí en DEV: "Javascript 101", en español, así que suscríbete para que no te la pierdas.

Redes Sociales
Twitter
Instagram
Youtube

JS 101 (4 - n) Comparisons

Valentiina VP — Wed, 13 Jan 2021 17:58:07 +0000

Hello everyone
Today we will talk about comparison operations in javascript. Remember this is the 4th article related to the Javascript 101 Fundamentals series, you can find all the related articles in this table.

Content
JS 101 (1-n) - Introduction
JS 101 (2-n) - Data types
JS 101 (3-n) - Type conversion

Comparisons

As in mathematics, in javascript there are comparison operations that allow us to better manage the logic and flow of our algorithms to obtain the appropriate solution and develop our systems. These operations are represented as follows.

Name	Symbol	Example
Greater than	`>`	a > b
Greater or equals than	`>=`	a >= b
Less than	`<`	a < b
Less or equals than	`<=`	a <= b
Equals to	`==`	a == b
Equals to (use stric)	`===`	a === b
No equals to	`!=`	a != b
No equals to (use stric)	`!==`	a !== b

The responses to these comparisons will always be Boolean: true or false. We are going to see some practical examples and understand some peculiarities of these operations.

String comparison

The comparison between strings is done character by character. We must always keep in mind that this comparison is not based on the location of a letter in the alphabet, but is based on the UNICODE system.

We are going to see the algorithm that allows us to solve these operations.

As I said earlier, the comparison is done character by character. In these first two examples, we only had one character. But the algorithm changes a bit if it is more characters:

1. 1. We translate the first two characters of both strings to UNICOD
2. If they are the same, we continue with the following characters and return to step one. This repeats for all characters until one greater / less than the other is found, at which point, it stops.
3. The string with more characters will always be greater (how is the case in example 4)

Comparison between different types

In these operations, Javascript automatically converts all operands to numbers. Remember how type conversions work by reading my previous post in this series: Type Conversion

⚠️ Undefined cannot be compared with another value because always will return false

Strict comparison

The difference between a simple(==/!=) and a strict(===/!==) comparison is that the simple comparison does not differentiate between data types as it converts all of them to numbers. The strict comparison does not do any conversion so it differentiates between different types of data.

A special situation

There are times that == handles peculiar Javascript data in a special way. This is the case of null andundefined. We said that == converts all data into numbers, if this were the case in these two types, null would be 0 and undefined be NaN, which should be false when comparing. On this occasion, == gives them a sense of equality more of meaning than of type, since both data have a sense of 'empty' or 'nothing', and in this case, if they are equal. Therefore, the result is true.

As we also said, === does not any conversion, and performs a comparison of both type and value, and in this case, null is a object, as we saw in the previous post Data types and undefined is a undefined type, therefore, when comparing them with the strict comparer the result is false.

For these reasons, it is recommended to use the strict version of the comparisons for greater precision, if necessary.

I hope you found this article interesting and useful. See you soon!

If you want to read more about Javascript:

If you want to read about other topics:

Follow me!
Instagram
Twitter

JS 101 (3 - n) Type Conversion

Valentiina VP — Sat, 09 Jan 2021 22:08:20 +0000

I wish all readers a happy new year!

I'll pick up the series I started last year and today we'll talk about type conversion. If you want to read the first episodes of this series, here is this table of contents.

Content
JS 101 (1-n) - Introduction
JS 101 (2-n) - Data types
JS 101 (4-n) - Comparision

In the previous post we learned about the types of data that we can find in this programming language.

In many cases, we will need to handle a specific type of data that perhaps, in its first instance, was declared as another type of data. These situations mainly occur when the data that our users enter into our system is handled. To control these situations, both in javascript and in many other languages, there is what is known as "type conversion".

Type Conversion

This conversion operation is quite simple in this language. The Javascript interpreter automatically converts the data to the data specified in its declaration.

For example, adding double/single quotes will interpret the content as a string type. If they are numbers as a numeric type. But sometimes, we will need to do an explicit conversion. Let's see how we can do it.

To String

To convert a data into a String, you just need to use the String (value) function.

To Number

There are several ways to convert data to number, including the Number(value) function, the parseInt(value, base) function, the parseFloat(value) function and the unary operator +. In this post we will see the conversion using the Number(value) function and we will talk about the others in another occasion.

String to Number

Boolean to Number

Undefined and null

Mathematical operations and expressions

On this occasion, the javascript interpreter converts the numerical strings into mathematical operations directly into numbers, solving the operations.

But the same does not happen with addition when mixing strings and numbers.

Addition, concatenation, or unary operator

The symbol + can mean three things in the programming world, two of them can be an addition operation or a concatenation operation. In a conversion to Number using the Number(value) function, it works as concatenation if at least one of the operators is a string of numeric value.

However, this same symbol is a unary operator, which used, as its name indicates, with a single operands, and located on the left side, works as an abbreviation for the Number(value) function, since it also converts to numbers . Let's look at an example.

There is a possibility that the result in both ways is different. In this table they shared on StackOverflow you can compare both ways.

To Boolean

To convert a data into a Boolean, you just need to use the Boolean(value) function.

As we can see, the conversion operation is not difficult, and its rules are easy to remember.

I hope you liked this post. Don't miss the next one. See you soon!

If you want to read more about Javascript:

If you want to read about other topics:

Follow me!
Instagram
Twitter

JS 101 (2 - n) Data Types

Valentiina VP — Sun, 02 Aug 2020 18:12:58 +0000

Welcome back!
I invite you to read the first post of this series JS 101 - Fundamentals

Content
JS 101 (1-n) - Introduction
JS 101 (3-n) - Type Conversion
JS 101 (4-n) - Comparisons

Let’s continue our learning about this language. Today we’re going to talk about:

Data types

Programming languages handle something known as strong typing, weak typing, dynamic typing, or static typing.

Characteristics of strongly typed languages:

You must explicitly specify the data type of a variable.
You can not change the data type after that variable. Doing so will generate errors.

The data types may vary depending on the language. For example, in Java, there are various types of numeric data, depending on the bit size of that number, or whether it is decimal or integer...

Characteristics of weakly typed languages:

There is no need to specify the data type of a variable.
You can change the data type of that variable at any time.

Many times strong typing is confused with static typing or weak typing with dynamic typing, but in reality, they are different concepts.

Characteristics of static typed languages:

The typing check is done during compilation.
If there is a data typing error, the program does not run and throws an error.

Characteristics of dynamic typed languages:

The typing check is done during execution instead of compilation.
If there is a data type error, the program will run as far as the error is found.

What data type does Javascript handle?

Javascript is of the weak and dynamic typed.

Javascript data types are not bound to any variables. Therefore, the internal interpreter during execution understands what type of data contains a variable and how it should handle it automatically.

Let's look at the differences between a strong and statically typed language, and Javascript:

//Code in Java: Strongly and static typed
String hello = "Hello World!";
int num = 123;
boolean isJavaCode = true;

//If you try to change any value for other type, generates an error...
hello = 123; //ERROR: incompatible types: int cannot be converted to String...

//Code in Javascript: Weakly and dynamic typed...
let hello = 'Hello World!';
let num = 123;
let isJavaCode = false;

//If you try to change any value for other type, NO generates an error...
hello = 123; // OK

Data types in Javascript

The data types handled by the Javascript interpreter are classified into Primitives and Objects.

Primitives

Numerics

Number: It is applied to both integer and float point (decimal) numeric values.

There are also the so-called special numerical values, these are:

infinity: Represents the mathematical infinity (∞). It is greater than any other number.
NaN:(Not a Number) Represents a calculation error.

let num = 123; //number

let division = 1 / 0 // infinity

let nanNum = Math.sqrt(-1); //NaN

BigInt: It is a data type recently added to the language, and in simple words, it is used to specify very very large integers. It is identified by adding an n to the end of the number:

//The "n" at the end indicates that it's a BigInt...
let bigNum = 1471581264892135468476313n;

👍 Mathematical operations in Javascript do not generate errors (execution will not stop if there are calculation errors), if there is an error you will simply get: NaN.

Characters, words, and sentences

String: can be words or a simple letter. They must be in quotation marks. In javascript you can use 3 types of quotes:

Simple and Double: They are both the same. You can use one or the other. Never mixed (' string ").
Backticks: They are quotation marks with extended functionality, which allow adding variables or expressions within the same string, using ${ }. It also allows us to suppress the concatenation (+) as it detects the spaces between words.

//Simple (' ')
//Double (" ")
//Backticks (` `)

let mySimple = 'Hello';

let myDouble = "World!";

let myBacktick = `${mySimple} ${myDouble} :Concatenation is not required here, can use others variables and join words`;

// Concatenation example without using backticks

let helloWorld = mySimple + ' ' + myDouble + ' :Concatenation is required here to join words or variables and to create spaces...';

True or False

Boolean: It has only two values: true or false. Mostly used to store values like "yes-true", "no-false". It's also the way conditional expressions are evaluated in conditional control structures.

let age = [8,10,18];

let isAdult = (n) => {
 if(n === 18) {
   return true;
 }else {
   return false;
 }
}

for(var i=0; i < age.length; i++) {
  console.log(`${age[i]} ${isAdult(age[i])}`) 
  //Return
  // 8: false, 10: false, 18: true
}

Strange or peculiar

Null: Is a value that indicates that the variable is empty, or that it is value is unknown.

//Explicitly declared. Indicates that the value is unknown at this time...
let myVariable = null;

console.log(myVariable); // null

Undefined: Indicates that the value of a variable has not been defined.

//Declare variable without initializing.
let myVariable;

console.log(myVariable); // undefined

❗ You can read more about null and undefined here: null / undefined

Symbol: It was added to the primitive data list in ECMAScript 2015. It's a different or peculiar data type. Lets you create unique identifiers. The values of the Symbol are kept private and for internal use, that is, its values can only be accessed by reference. It's usually used for debugging or to identify the keys (properties) of an object and avoid overwriting it. Later we will go deeper into this data type.

//Create a symbol
let id = Symbol();

//Symbols are unique
let id2 = Symbol();
isIdentique = id === id2 
console.log(isIdentique) // False

/*You can add descriptions to 
identify them if you want you 
to have many symbols in your code, 
but it does not alter the result*/
let id3 = Symbol('My symbol 3');

Object

Objects allow you to store collections of data or code structures that are more complex than primitive data. In simple words, an object is a value in memory that is accessed through an identifier. Its literal representation is by means of the key (property) / value pair. There are different types of objects, but these we will see later.

//Literal representation
// obj = {key:value}
// Each pair key/value is separated by a comma, except the last one
// It can store anything, including functions

let myObject = {
 name: 'Valentina',
 brothers: 2,
 isHasPets: true,
 helloWorld: function() { 
  console.log('Hello World!')
 }
}

// Accessing the data = obj.key
console.log(myObject.name);  //Valentina
console.log(myObject.brothers);  //2
console.log(myObject.isHasPets);  //true
myObject.helloWorld();  //Hello World!

❗ Difference between primitives and objects
Primitives are unique values. They do not contain their own methods. (Only through wrapper objects - we'll see later)
Objects store more complex data collections and structures contain methods of their own.

With this general coverage, you already know in a simple way the different types of data that exist in Javascript...

... But, as we said in the beginning, this data is not specified when declaring the variables, so how can we know exactly what type of data the Javascript interpreter is identifying? Well, for this exist "typeOf".

typeOf

It allows us to know what type of data is the value of a variable, returning: string, object, boolean, undefined, etc.

// You can use it as:

// an operator: typeof variable
typeof true; //boolean
typeof {};  //object
typeof 'Hello World'; //string

// a function: typeof(variable)
typeof(123); //number

⚠️ When tested with a variable of type null, it will return that it is an object, this is a language error because as we have seen, null belongs to primitive data types.

If it comes from strongly typed languages, maybe you can better understand TypeScript, which we can say is the strongly-typed version of Javascript, although it is much more than that and we will be dealing with it later.

With this, we can finish this post. I hope you have learned a lot, do not miss the next chapter of this series. See you soon!

JS 101 (1 - n) Introduction

Valentiina VP — Wed, 27 May 2020 17:22:13 +0000

Through this series, we will try to explain in a simple way the fundamentals of Javascript.

Content
JS 101 (2-n) - Data types
JS 101 (3-n) - Type Conversion
JS 101 (4-n) - Comparisons

JS and HTML

When searching for a web page in our browser, it makes the request to the server where the web is hosted and shows it to us. This page that the browser shows us would be cold and static, if Javascript is not used in it. That is why we say that Javascript is a language that allows "animating" web pages.

For a script (piece of code) in JS to be run in the browser, it must be embedded in the HTML of our page, like this:

<html>
 <body>
  <script>
    console.log('Hello reader!')
  </script>
 </body>
</html>

Or you can also create a external .js file and then give it's path inside the src attribute provided by the HTML <script> tag, like this:

<html>
 <body>
  <script src="/path/file.js"></script>
 </body>
</html>

Which is better to use?

It depends of your script. If your script will contain complex logic, it's recommended that it be external, otherwise, you can embed it in the HTML itself.

⚠️ Be careful: If you choose use script externally, you will not be able to embed code inside the <script> tag, as the src attribute will ignore it.

✗ This will not work:

<html>
 <body>
  <script src="/path/file.js">
    //code here...
    console.log('ERROR!')
    //code here...
  </script>
 </body>
</html>

✓ If you want to do it, it will have to be this way:

<html>
 <body>
  <script src="/path/file.js"></script>
  <script> 
   //code here...
   console.log('GOOD!')
   //code here...
  </script>
 </body>
</html>

Code

Semicolon or not semicolon?

Many memes have come out of the semicolon. And it is that its strict use in many programming languages meant that if it were forgotten, it could generate errors in the execution. Imagine 1000 lines of code, where your only mistake was forgetting a semicolon on line 500. It sounds simple, but finding that mistake could have been time consuming and very frustrating.

However, Javascript is a language that allows you to omit the semicolons at the end of the declarations, as long as there is a line break between them.

//This
console.log('Hello');
alert('World');

//Is the same as:
console.log('Hello')
alert('World')

But let's not be confused:

//This
console.log('Hello'); alert('World');

// ✗ Is not same as:
console.log('Hello') alert('World')

This omission is made possible by something called automatic semicolon insertion, which, at runtime, the language itself "adds" (not literally) the necessary semicolons. You can read more about this in ECMAScript Specification

⚠️ But this doesn't happen in all cases.Not using it can generate unexpected errors. For this reason, it's always recommended to add the semicolon, as a convention.

If for styling reasons you don't want to see it in your code, I advise you to add it and then use a code formatter, like Prettier, with which you can remove it correctly.

Comments

Comments will allow you to add hints or clarifications to yourself or to other programmers who will use your code.

These can be of two types, line //, or block /* */.

//I am line comment

/*
 I am block comment.
 Use me for long comments.
 I will be very useful to you in the future.
*/

Use strict

It's used to indicate to the browser that you want to use modern Javascript. This happens because after the modifications made by ES5, the browsers stopped detecting the old features of the language, therefore, to avoid this, the new modern features were disabled by default so that the old ones kept working and, therefore They should be enabled when you want to use modern Javascript.

Directive "use strict" must be added to the start of your code, otherwise it will not work.
Once added, the browser will enter "modern mode" and cannot be reversed. So if you use any pre-ES5 function it won't run, and in some cases, it will generate errors.

"use strict";

//Modern syntax...

let a = "ES6 new variable declaration";

function MyClass() {
 constructor();
};

Currently, this directive can be omitted, since, when using classes or modules in your code (features of modern javascript) this directive is "activated" automatically.

Variables

A variable, in simple words, is a box where you keep things. Those things, in code, can be words, numbers, or more complex expressions. If you want the most complex form of explanation, we would have to talk about references or pointers, among other things, that don't correspond at a basic level. We'll talk about it later.

The old way of declaring variables was through the reserved word var.

var myName = 'Valentina';
var favoriteNum = 7;

After the arrival of ES6, a new way of declaring variables was added, which are called block scope variables. Later we will specify why they were called like this and their differences with var, meanwhile, you can read this post in which I explain part of the topic Javascript behind scenes

let: is the statement that most directly replacesvar. It is used to assign variables that can change during program execution.
const: used to assign constant variables, that is, they will not change.

let name = 'Laura';
const birthday = '8/18/1990'; //never change

How do you change the value of a variable?

Before learning how to change the value of a variable, we must understand 3 concepts: declaration, initialization and assignment.

declaration: create and name a variable, but without a value.
initialization: You give an initial value to the variable.
assignment: assign a new value to the existing variable.

Declaration and initialization can happen on the same time.

//declaration
let name;
//initialization
name = 'Valentina';
//assignment
name = 'Jean';

//Declaration and initialization at same time
let name = 'Valentina';

As you may notice, assignment is synonymous with changing the value to an existing variable.

⚠️ If you try to change the value to a variable declared as const, it will generate an error.

Interactions in the browser

When we use JavaScript in the browser, we use the console to test our code. But many times we want to use more interactive messages. For this we are provided with alert,prompt and confirm. All of them generate a popup, but they work differently. Let's see it:

alert: Allows the user to see an alert message, which will disappear once the user presses OK. You can try it in the following link Basic Alert

alert('Alert! This is Javascript!');

prompt: It allows the user to enter data and then store it in a variable. You can try it in the following link Basic Prompt

let prm = prompt('What is your favorite number?');

Prompt allows a second argument, which would a default value. You can try it in the following link Basic Prompt 2

let prm = prompt('What is your favorite number?', 7);

confirm: It allows you to ask a question, which can be answered by the user using the "confirm" or "cancel" button. If he presses confirm, it is taken as "true" (yes), if he presses cancel, it is taken as "false"(no). It also allows storing the response in a variable. You can try it in the following link Basic Confirm

let quiz = confirm('Do you love javascript?');

Wow! I think that was enough for today. In the next post we will be talking about data types in Javascript, conversions, operations, among others. Do not miss it! See you soon!

If you want to read more about Javascript:

If you want to read about other topics:

Types of tests - Software Testing (II)

Valentiina VP — Sat, 23 May 2020 17:14:18 +0000

Continuing with our Software Testing series, today we will take a short tour of the different types of tests that our code can perform. Here you can see the posts of this series:

Content
Introduction
Unit tests (very soon)

Unit Tests

They are functional tests that allow the detection of problems in an individual module. It focuses its activity on exercising the logic of the module following the structure of the code (white-box technique) and the functions that the module must perform attending to the inputs and outputs (black-box technique).

The percentage of code tested by unit testing is called software coverage. In the next post we will be delving more into unit tests.

Integration Tests

They are functional tests that allow to detect problems between related modules and previously individually tested by unit tests. They take into account the assembly mechanisms of fixed modules in the program structure, that is, the interfaces between the components of the software architecture.

There are different types of integration tests depending on the order of integration. The order of integration chosen affects various factors, such as: the way of preparing cases, the necessary tools, the order of coding and testing the modules, the cost of debugging, and the cost of preparing the cases. The fundamental types of integration are as follows:

Incremental integration: the following module to be tested is combined with the set of modules that have already been tested. There are two fundamental types:
- Ascending (Bottom-up): it begins with the node modules in hierarchical tree.
- Descending (Top-down): it begins with the root module.
Non-incremental integration: Each module is tested separately and then all are integrated at once and the entire program is tested. It is also called Big-Bang because the number of modules grows instantaneously.

Ascending Incremental Integration

The characteristics of bottom-up integration are:

You can work with the modules individually or combine the low-level modules in groups that perform some specific function in order to reduce the number of integration steps.
A driver module is written for each group, which is a module written to allow simulating the call to the modules, entering test data through the input parameters, and collecting the results through the output parameters.
Each group is tested with its driver module.
Driver modules are removed from each group and replaced by higher level modules in the hierarchy.

For example, the stages of integration would be 6 in the case of having the following modules.

Stage 1, 2 and 3: Unit tests of E, C and F are carried out. The driver modules are represented with a dashed border in the following graph.

Stage 4 and 5: On the one hand, the B unit test and the B-E integration (or interface) test are carried out simultaneously, and on the other hand, the D unit test and the D-F interface, simultaneously. The modules already tested in previous stages are represented with a thick border in the following graphic.

Stage 6: Module A is incorporated and the complete program is tested, which does not require a driver module, since all the input and output management code for the program is present.

Descending Incremental Integration

The top-down incremental integration begins with the main module (higher level or root module) and gradually incorporates subordinate modules. There is no general rule for determining subordinate modules that should be incorporated first. As a recommendation, critical parts and input / output modules should be incorporated as soon as possible. There are two fundamental orders of downward integration:

First in depth: branches of the modular tree are completed. In the example above, the sequence of modules would be A-B-E-C-D-F
First in width: horizontal levels of modular hierarchy are being completed. In the example above, the sequence of modules would be A-B-C-D-E-F.

The characteristics of the top-down integration are:

The root module is the first to be tested and simulators modules (stubs) are written, to simulate the presence of absent subordinates, who will be called by the root module.
Once the root module has been tested, one of the stub module is replaced by the corresponding module in the chosen order, and new stub module are incorporated to collect the calls of the last incorporated one.
The detailed process for the root module is repeated, that is to say, the corresponding tests are executed each time a new module is incorporated and at the end of each test, a stub module is replaced by its corresponding real one. It is a good idea to repeat some test cases from previous runs to ensure that no new defects were introduced.

Coding subordinate stubs modules is more complicated than creating drivers modules. The stubs modules must simulate that they take control of the call and that they do something with the parameters passed to them.

For example, using the same module design as in bottom-up integration, and using the first order in depth, 6 stages would be necessary.

Stage 1: Unit test of A is performed. The stubs modules are represented with a dashed border in the following graph:

Stages 2 and 3: The unit test of B and the integration (or interface) test A-B are carried out simultaneously, and then the unit test of E and the interface B-E are carried out simultaneously. The modules tested in previous stages are represented with a thick border in the following graph.

Stage 4: Test of module C and interface A-C is carried out simultaneously.

Steps 5 and 6: The unit test of module D and the A-D interface is performed simultaneously and then the unit test of module F and the D-F interface, leaving all the integration tested.

Non-Incremental Integration

Non-incremental integration is the only case where unit testing and integration are completely separate. The characteristics of non-incremental integration are:

Each module requires to be tested:
- From a driver module that transmits the test data to the module and displays the results of the test cases.
- The stubs modules necessary to simulate the function of each module that are subordinate to the module that we are going to test.

After testing each module separately, they are all assembled at once to form the complete program.

Comparison between integration types

Advantages of non-incremental integration	Advantages of incremental integration
It requires less machine time for testing as the combination of modules is tested in one go.	It requires less work, since fewer drivers and stubs modules are written.
There are more opportunities to test modules in parallel.	Defects and errors in the interfaces are detected earlier, as you begin to test the connections between the previous modules.
	Debugging is much easier, since detecting the symptoms of a defect in one step of the integration, it is very likely to be attributed to the last built-in module.
	The program is examined in more detail, as each interface is checked.

Ascending Incremental Integration	Descending Incremental Integration
It is advantageous when there are defects at lower levels of the program.	It is advantageous when there are failures in the upper levels of the program
Entries are easier to create	Before incorporating I / O, it is difficult to represent cases and the inputs can be difficult to create. After incorporating I / O functions, the representation of cases is easy.
The program, as an entity, does not exist until incorporating the last module.	Before incorporating the last module, you can see the previous structure of the program.
Drivers modules are required. Drivers modules are easy to create.	Requires stubs modules. Stubs modules are not easy to create.
It is easier to see the test results.	Difficult to see results.
	It induces to delay the completion of the test of some modules.

The selection of an integration strategy depends on the characteristics of the software and sometimes on the project planning.

System or implantation tests

They are non-functional tests that verify that the complete system meets the functional requirements and specified technicians, and that it relates correctly to other systems. Ademais incorporates other tests such as:

Overload or stress tests: They allow evaluating the behavior of the system when subjecting it to a limit situation such as excessive demand for requests, use of the maximum amount of memory, working with little memory, having many users performing the same operation at the same time, use the maximum volume of data.
Compatibility tests: They allow you to test the system in different environments, media or operating systems and see if there are any errors in appearance or operation.
Data access and security tests: They allow to test how the system responds to external attacks such as unauthorized breaches or camouflage of malicious code in a data entry.
Recovery and fault tolerance tests: They allow to cause external anomalies such as electrical, device, external software or communication failures, and to see that the system recovers without data loss and without integrity failures and the time it takes to do so.

Validation or acceptance tests

They are non-functional tests that are used to check if the final product conforms to the initial requirements of the software and is based on the actions visible to the user and on the outputs of the software that the user can recognize.

There may be alpha tests and / or beta tests:

Alpha: Associated with contracted software. They are performed by the client in a controlled environment under the supervision of the company that develops the software. The software developer will take note of possible errors and usage problems.
Beta: Associated with software of general interest. They are performed by trusted users in their real work environment without direct control of the software company. The user will report the results of the tests.

Validation or acceptance tests

They are tests that are performed to avoid side effects. They are applied every time a change is made in the software to verify that unwanted behavior or errors do not appear in other modules or parts of the software.

Strategy for the application of tests in the classic life cycle

The application strategy and test planning aim to integrate test case design into a series of well-coordinated steps, by creating different test levels with different objectives. In general, the test strategy follows the steps shown in the following image during the software life cycle:

Documentation of test design

The documentation of the tests is necessary for a good organization of the tests, as well as to ensure their reuse. Documentation of test execution is essential for effectiveness in detecting and correcting defects, as well as recording results of test execution. The documents generated for each execution are:

Test history: documents the relevant events that occurred during the execution of the tests.
Incident Report: documents each incident that occurred in the test and that requires further investigation.

As we have seen, there are many types of tests that will allow us to correct errors and will make our software a better product. Do not miss the next post dedicated exclusively to unit testing. See you soon!

Introduction - Software Testing (I)

Valentiina VP — Sat, 09 May 2020 19:26:12 +0000

Hi again, everybody. During a series of posts, we will be talking about software testing. And in order to address this topic, we will start by talking about two concepts that surround: quality and standards. Here you can see the posts of this series:

Content
Types of tests
Unit tests (very soon)

Software quality

Software quality is the degree to which the software meets the functional requirements established with the client, with explicitly documented development standards and with the characteristics expected of any professionally developed software.

We can deduced that:

If the software does not meet the initial requirements, it will not be of quality.
Development standards guide how to make the software, so if the software does not meet these standards, it will not be of quality.
If the software has major errors, or is not easy to use or is difficult to maintain, it will not be of quality.

Determining quality is very complicated due to the nature of the software, since it is not a tangible element like other industrial products, but it must be free of errors, allow measurements and validate the development process.

Throughout the software development process, periodic verifications are performed that should allow:

Verify that the product is being built correctly.
Validate that the correct product is being built, that is, the one that the user really wants.

Certification standards

Standardization is the process of preparing, disseminating, applying, and improving the rules that are used in different scientific, industrial, or economic activities to order and improve them.

Standardization allows:

Simplify, that is, reduce the models to be left with only the most necessary ones.
Unify to allow exchange at the international level.
Specify to avoid identification errors by creating clear and precise language.

Certification is the action carried out by a recognized entity, independent of the interested parties, through which it is established that an organization, product, process or service complies with the requirements established in the standards or technical specifications. It leads the company to differentiate itself from the rest and activates the market by demonstrating that it follows quality standards. Applying for a certification is voluntary, costs incurred and must be renewed periodically. The best known organizations that we can mention are:

ISO

International Organization for Standardization is a non-government agency responsible for promoting the development of international standards for manufacturing, commerce and communication for all industries except electrical and electronics. Its main function is to seek the standardization of product and security standards for companies or organizations internationally. The standards it produces are called ISO standards. The ISO 9000 family of standards are the most widely used in the software industry.

IEC

International Electrotechnical Commission is a standardization organization in the field of electrical, electronic, and related technologies. Numerous standards are developed in conjunction with ISO and are called ISO / IEC standards. For example, ISO / IEC 90003:2014 provides guidance to organizations and companies on the application of ISO 9001:2008 for the acquisition, supply, development, operation and maintenance of software and related support services.

IEEE

Institute of Electrical and Electronics Engineers is a worldwide professional technical association associated with standardization, among others. Currently is the largest international non-profit association made up of professionals in new technologies, such as electrical engineers, electronic engineers, computer engineers, biomedical engineers, television engineers. communication and mechatronics engineers. According to the same IEEE, it's job is to promote creativity, development and integration, share and apply advances in information technology, electronics and science in general for the benefit of humanity and the professionals themselves. They collaborate with ISO and IEC on common problems. The best known standards of this organization are:

IEEE 730: Plans that ensure software quality.
IEEE 829: Software testing documentation.
IEEE 982.1, 982.2: Standard dictionary of measures to produce reliable software.
IEEE 1008: Software unit tests.
IEEE 1012: Software verification and validation.
IEEE 1028: Software review.
IEEE 1044: Standard classification for software anomalies.
IEEE 1061: Standard for a software quality metrics methodology.
IEEE 1228: Software security plans.

Tests

Extensive testing of the software is impractical, as not all of it's functionality can be tested, even in small, simple programs. The purpose of testing is to detect defects, software bugs, so a test is successful if a defect is discovered.

The testing process begins with generating a test plan based on the project documentation and the software documentation to be tested. From this plan, the specific tests are detailed, they are executed with the test cases and the results are obtained. Results may indicate errors, and errors should then be documented and reported in order to correct them and rerun the tests.

Test plans should not be made thinking that there are no flaws; one must assume that there always are. As tests, they should be planned and systematically designed to detect the maximum number and variety of defects with minimal time and effort. Undocumented or not carefully designed testing should be avoided.

Testing should focus on two objectives: testing whether the software is not doing what it should be, and testing whether the software is doing what it should not be, that is, whether it causes adverse side effects. It's common to forget this last objective.

Types of tests

There are different ways to classify the tests and these are not mutually exclusive:

Functional and non-functional: The former are intended to verify some functional requirements of the software and the latter are not. Examples of non-functional tests: those that indicate the effort required to learn how to handle that software, analyze the code and locate an error, support changes and facilitate the tests associated with those changes, or migrate the software to another environment.
Manuals and automatic tests: The former follow a detailed plan and there is no automatic process for executions. The second has an automatic process that can be repeated as many times as you like comfortably.
Dynamics and static tests: The former are done while the software is running and the latter are not.

There are operations that certain tools perform in the code to detect defects, although they are not strictly tests:

Code Validation: allows you to ensure that the code complies with some language standard.
Debugging: It allows to detect the code that gives erroneous results in the execution.
Code lines analysis: it allows to detect, for example, the code repeated in several places, review the code that is documented and that will facilitate the task of automatic generation of documentation (Javadoc in Java), find commented code lines that take up space even if they don't work and can be removed using a version control system.

Well, it was enough for today. I know this introduction has been very theoretical, but it will be much more visual in the next post. I hope you continue with me on this software testing tour.

If you have had experiences worth telling while doing your software tests, I would love to read them!

See you soon!

Javascript behind scenes

Valentiina VP — Wed, 29 Apr 2020 15:40:53 +0000

When we start learning a new language, we forget to understand what happens when we execute our lines of code. We want to see our printed output on the console, or see its actions running, and we forget to understand how this is possible. Understanding how languages work internally will allow us to advance more quickly in their learning. So today, I want to summarize how JavaScript works behind the scenes.

How browser execute our code?

Doing a review of what I talked about in my previous post Java vs Javascript, let's continue to delve into the execution of our code.

JavaScript is always hosted in some environment. That environment is almost always a browser, or as in the case of NodeJS it can be on a server. Inside this environment there is a engine that will execute our code. This engine is different in each browser: Google's V8 for Chrome and Opera, Mozilla's Gecko and SpiderMonkey for Firefox etc...

The first thing that happens inside the browser engine is that our code is parsed by a parser, which basically reads our code line by line and check if the syntax of the code we gave you it's correct. This happens because the parser knows the syntactic rules of Javascript so that the code is correct and valid. If it encounters an error, it will stop running and It will throw that error.

If our code is correct, the parser generates a structure known as AST or Abstract SyntaxTree. The syntax is "abstract" in the sense that it does not represent all the details that appear in the actual syntax, but only the structural or content-related details. This structure is translated into machine code and it is at this moment that the execution of our program actually occurs.

Context execution

As I mentioned in the previous post, when we talk about JavaScript code execution, we need to keep in mind the execution stack and scope.

When the code is executed, the JavaScript interpreter in a browser takes the code as a single thread, this means that only one thing can happen at a time, and appends these actions or events into queues, in what is called the execution stack.

Who creates the contexts?

I'm not going to give a great explanation about this because basically the contexts in the browser are created by the functions and, in some cases, by the called blocks-scope ({let / const}). Contexts are stored in objects that also differ in global and local. These contexts in turn create a scope.

Global Context and Local Context

The execution context can be defined as the scope in which the current code is being evaluated. When the code is run the first time, the browser automatically creates the Global Execution Context. We can define the global context as that code that is not inside a function or inside blocks-scope.

The local context is created when a declared function is called. When the synchronous execution flow enters that function to execute it's instructions, it creates it's local context for that function call.

The global context is located in the first position from bottom to top in the execution stack. Every time a new context is created when a function is called, this placed at the top of the queue. Once it's executed, they are eliminated from top to bottom.

Context Object

I mentioned that contexts are stored in objects. These are known as context objects. This does not happen as simply as it's to pronounce it. Let's see it:

Creation of the variable object

Argument object is created, which stores all arguments (if any) in a function.
The code is scanned for function and variable declarations and creates a property in the variable object (VO) that points to those functions and variables before execution. This process is known as hoisting.

Hoisting: Elevate functions and variables by making them available before execution, albeit in different ways:

Functions: only those that are declared. It makes them fully available.
Variables: makes them available but as undefined.

Scope Chain

The scope answers the question: where can we access? Each new function call creates a new scope that makes what is defined in it accessible. Accessibility within that scope is defined by the lexical scope, which is practically the one that identifies the position of 'something' in the code. As the flow of execution is followed, a chain of scopes belonging to the object variable is created to finally create the context object.

If you come from a programming language like Java, you can conceptualize the scope as access modifiers (public, private, protected ...), since the scope is the ability to access from one place in our code to another. The scope is privacy. We will see it in practice with the code of the image that I have put as an explanation.

In the scope chain, the innermost function of the chain is placed in the first position from bottom to top, this implies that this function has access to all the functions that will be above it in the scope chain. For this reason, the execution is successful. But what would happen if we tried to call the function second() from the global scope?

The global scope cannot access the local scope of internal functions, as is second(). Let's see another example:

Although both functions are declared in the global scope, the b() function cannot access the local variables of a(). Simply put, the scope chain works like this:

Lexical Scope

Before we mentioned the lexical scope. This is best seen when we take the example of the bloks-scope and the declaration of variables ES5 (var).

Although both variables are declared within blocks ({}) within the lexical scope, the scope is only assigned to "let". This happens because the function declaration with "var" is not strict, and its scope is only assigned when it's lexical scope is inside a function. However, "let" is considered a block-scope just like "const", because when declared within blocks they generate their own local scope.

For this reason, many professionals in the field of programming believe that the correct concept is to literally define this scope when the "let" is declared inside blocks, such as those created with if conditionals. That is to say:

And not like this:

To finish this part of the process of creating the context object, I wanted to remember that we should not confuse the execution stack with the scope chain, both refer to different concepts as we have already seen.

The execution stack is how the function calls are placed inside the execution stack, storing their context, while the scope chain refers to the scope of accessibility existing between the different contexts.

Define the value of THIS

And to finish the first phase for creating the context object, you must assign a value to "this". This is the variable that will store each of the contexts.

In a normal function call, this keyword simply points to the global object, which, in the browser's case, is the window object. In a method call this variable points to the object that calls the method. These values are not assigned until a function call is made where it's defined.

Once the call is made, "this" will take the context of the function where it was defined. Let's see it more clearly with this example on the console.

When the function is called for the first time, it takes the value of the global context that is window, while when calling it assigning a new local context created by the person object variable, "this" takes this new local context as value.

Execution code

In this way, the context object is created and goes to the second phase, which is the line-by-line execution of the code within each context until each function call ends and they are removed from the execution stack.

This has been an explanation of how the execution of our Javascript code would be visualized internally. I know the terms can be confusing, but I hope I was able to help you understand this process. See you soon!

If you want to read more about Javascript:

If you want to read about other topics:

Follow me!
Instagram
Twitter

Java VS JavaScript

Valentiina VP — Fri, 24 Apr 2020 04:05:58 +0000

It's not a surprise that when we begin to learn programming we confused these two languages, since they both have similarities in their names. But today we are going to understand what differentiates them and why we must learn not to confuse them. Let's start.

Java	JavaScript
It's need a virtual machine and a development kit to be able to work.	It's only need a text editor to work.
It's form of execution, as we saw in my previous post, places it in a language both compiled and interpreted, through the use of its JVM.	It's an interpreted language, as we also saw in my previous post.
In original nature it was mainly created to be used on the back-end side.	In original nature it was mainly created to be used on the front-end side.
It's methodology is based on classes within object-oriented programming.	It's methodology is based on prototypes within object-oriented programming.
It's strongly typed.	It's weakly typed.
It's debugged in two phases.	It's debugged in one phases.

These are some of the main differences, there may be others in depth in both languages, but we will address the ones I have mentioned. If you can contribute more differences, feel free to add it and open a discussion, so we all learn much more.

Taking these differences in mind, will they have any characteristics in common? Yes, few, but there are.

Both languages are C-based
Both are cross-platform programming languages
Both are languages that, due to their time on stage and wide community, are classified as robust languages.

JAVA

Oracle is the private company in charge of this language. Today it's in JAVA SE 14 version.

Java is made up of different platforms:

Java SE (Standard Edition) is used to build desktop applications, console applications with Swing and JavaFX.
Java EE (Enterprise Edition) is used to develop web applications. It comes with many technologies.
Java ME (Micro Edition) is used to develop mobile applications.

As I also mentioned, in order to run a program in JAVA, you must first have installed the Java Development Kit, but what is this?.

Java Development Kit (JDK)

In common terms, the JDK is the box that contains all the tools necessary develop and execute code written in this language.

The main tool that we can mention is the javac compiler, it allows compiling the .java source file and transforms it into a bytecode with .class extension. Another important tool to mention within the JDK is javadoc, which allows you to generate the documentation for the code. The JDK also includes the JRE, which is the Java runtime environment, that is, the place where the code is executed.

JDK vs JRE

As its name implies, JDK is a tool used for development, so it is generally only used by the Java developer community, but not the end user. By contrast, the JRE is the tool that the end user needs to run their program or application.

But as a curious thing, the JDK cannot be installed without the JRE, however, the JRE can be installed independently. This makes sense, since as programmers we need to test our code, therefore we need their execution environment to be able to do it, while end users only need to execute it.

Java execution

As we saw in my previous post (Classification of computer languages (III)), Java is a compiled language, but through its VM you can choose whether to interpret the bytecode or compile it. As we can visualize it in the previous image.

Classes-based (OOP)

It's based on creating a mold structure called class where the fields and methods that our objects will have are specified. Every time we need an object we create an instance (or copy of the object) using the class as a template.

Strongly Typed

The concept refers to the strict use of data types when declaring variables or using parameters. Personally, it is a feature of languages like Java that are very useful to me, especially at the time of data entry by the user. Allows better control of input data.

It is also a very important feature when programming, since, knowing the types of data to be used from the beginning, you will have greater control when allocating the spaces in the memory of the data. If you are an intermediate programmer, you will know that an INT is not the same as a BYTE and the effects this has on the memory, weight and execution time of the code. Later I will talk about this in another post.

Java Debugging

At the time of executing our java code, the debugging is done in two steps:

At compile time: When the javac compiler tries to generate the bytecode, it first parses the syntax, and if it is not correct, it warns of this error and the code doesn't execute.
At runtime: If the first step does not generate errors, the code is executed, but it may happen that the user enters an unexpected data type, or tries to access an index that does not exist in an array, or the basic errors in Java mathematical operations such as divisions by zero or saving strings where they should be numbers. The program runs, but at the time of finding one of these errors, it will hang and not work properly.

JAVASCRIPT

Javascript is also registered under the Oracle company, however, 1997 adopted the ECMA non-profit organization standard, which later specified it as ECMAScript.

This is a very versatile language, since, although it is naturally based on prototypes, as I mentioned earlier, it easily adapts to other methodologies.

JavaScript Execution

JavaScript is an interpreted language, although other developers think that it can also be compiled. If you are interested in reading about this thought, you can access it here: You Dont Know JS.

The first thing that happens inside the engine is that our code is parsed by a parser, which basically reads our code line by line and check if the syntax of the code we gave you it's correct. This happens because the parser knows the syntactic rules of Javascript so that the code is correct and valid. If it encounters an error, it will stop running and It will throw that error.

When we talk about JavaScript code execution, we need to keep in mind the execution stack and scope. On these two concepts I will delve into my next post Javascript behind scenes.

Prototype-based (OOP)

In this methodology there are no classes, only objects. To create an object with the same structure as another, the term object cloning is used. This cloning is done through a prototypical object, which is used as a template to obtain more objects equal to it.

Weakly Typed

For many programmers, this is an advantage, as it constantly eliminates thinking about what kind of data to use and focusing on logic. Another possible advantage is being able to change the type of the variable on the fly, such as assigning a string to an int.

In Javascript curious things happen that in a strongly typed language would not happen, such as when comparing strings and numbers. Let's see an example in the browser console:

Admittedly, these problems are easily solved using strict comparators (===), but it might confuse those that come from a strongly typed language.

As we can see, these languages cannot be confused, since their independent characteristics allow us to see that there is no reason for it. Remember, if you want to contribute more to this article, feel free to do so!

See you soon!

Classification of computer languages (III)

Valentiina VP — Wed, 15 Apr 2020 22:15:18 +0000

We have been analyzing the ways of classifying computer languages, today we will continue with the classification by translation and method of execution. If you want to start the thread of these posts, I leave the table of contents here.

Content
Classification Part I
Classification Part II

Translation and method of execution

The code written for a computer program is known as the source code. This code is saved in a file known as source file and will have to be translated into language machine to be able to run.

Three language groups can be considered programming considering how to translate to machine language and to execute:

Compiled languages.
Interpreted languages.
Managed execution languages or of machine virtual.

Some languages like Prolog can be considered compiled or interpreted since they have compilers and interpreters.

Compiled languages

They have a compiler or program that translates the source code to machine code saving the result in an executable file. This compiled code that is generated is called an object code. With that file you can run the program as many times it is necessary without having to repeat the process, so the waiting time between executions is minimal. At runtime the executable file is launched on the platform for which the compiler was made.

Characteristics
There is an executable file for the real machine.
The translation process is done at compilation time and only once.
Execution is very fast since the executable is in machine language.
The executable only works for the platform it was created for.
The user who executes does not have to know the source code, he only has the executable code that is not easily manipulated to obtain the source code, and as a consequence the programmer has the code most protected source.
The executable will not be generated if there are lexical errors, syntactic or semantic.
Interrupting execution can be difficult for the system operational and may affect the platform.
Modifying the source code implies going back to generate the executable file.

Example: ADA, C, C++, COBOL...

We see them more in desktop software since they require greater resources and access to certain files. Also due to the greater weight that they usually have in their executable files.

Interpreted languages

They execute the instructions directly, without generate object code. They need an interpreter or program in memory to that at runtime the code is translated from source code to machine language. Your instructions or rather the source code, written by the programmer in a high-level language, is translated by the interpreter to a language understandable to the machine step by step, instruction by instruction. The process is repeated every time the program is run, the code in question.

Characteristics
There is no executable file.
The translation process is done every time it is run.
The execution is slow since the execution process the translation has to be added.
The file can be run on different platforms provided there is an interpreter for them.
The user uses the source code to execute program.
Lexical, syntactic or semantic errors can appear in the execution
Interrupting execution normally only affects to interpreter and not to the platform.
Allows dynamic data typing. It is not necessary initialize a variable with a certain data type.

Example: RUBY, PYTHON, PHP, JAVASCRPT, VISUAL BASIC 6 and previous...

They are seen in the development of applications or websites that go accompanied by frameworks that greatly facilitate the programming.

Managed execution languages or machine virtual.

These languages initially need a compiler that in programming time translates the source code to a cross-platform intermediate code, then you need other software that translates that intermediate code to machine code. This is the case of languages like Java or .NET

In the case of virtual machine languages such as Java happens that:

At compile time the Java compiler generates the intermediate code called bytecode Java platform independent.
At runtime, you need a Java Virtual Machine (JVM) that interprets the bytecode, virtual machine is a software that simulates a machine real with your operating system.
It acts as an intermediary with the real machine, so virtual machines are different for Linux, Windows, Mac and Solaris.
This scheme provides many of the advantages of compilation and interpretation, getting rid of some drawbacks. Mainly:

Virtual Machine Advantage
Portability and speed: The intermediate code is now free of syntactic errors, and it is a very simple code (in the style of machine code).
Multiplatform: If there is an interpreter for this code in different platforms, the same code can be run on each of them.
Stability: intermediate code is not executed by a CPU directly, but yes by a virtual CPU: really, by the virtual machine interpreter, which is a program and not a real chip It allows greater control over this code, making work easier to prevent uncontrolled code from affecting stability of the current platform.

In languages of managed execution such as Microsoft's .NET platform happens that:

At compile time, the compiler generates the CIL (Common Intermediate Language) code of independent platform.
To run it is necessary to have on the client computer the version of the .NET Framework (CRL Common Runtime Language - proper execution engine) and the last compilation phase is done, in which the CRL will translate intermediate code into machine code using a JIT (Just In Time) compiler.
To directly run a .NET application using the CLR, you need the so called "CLR Hosts". CLR Host is an application responsible for loading the CLR in an operating system process, create the application domains required within that process and run the application inside the application domains.
The .Net platform has a common system of types known as CTS (Common Type System). All types of data are collected in the CTS and operations that can be used from a language .Net. It doesn't matter if we use Visual Basic .Net, C #, COBOL, Perl or Pascal. The data set to use is always the same. The CTS also includes the operations that can be done on the data.
There is a subset of the CTS made up of data types and operations that all .Net languages must implement to be compatible with the rest. This subset is known as CLS (Common Language Specification).

Common features between managed machine and virtual machine languages
There is an intermediate code that runs on a specific software but not an executable.
The initial translation process is done before execution and the final translation process is done every time running.
Execution is not as fast as in compiled languages but it is faster than in languages interpreted.
The file can be run on different platforms as long as the specific software exists.
The user does not have the source code, only the intermediate code that is not easily manipulated to get the source code, so the programmer has more protected source code.
Lexical, syntactic or semantic errors are detected in the compilation phase, and if they exist they are not will generate the intermediate code.
Interrupting execution normally only affects the interpreter and not to the platform.
Modifying the source code implies repeating the compilation process.

Client-server architecture

The client-server architecture basically consists of a client program that makes requests to a server. It is most useful when the client or the server are communicating through a network, although it can also be apply when they are on the same machine.

It differentiates between languages that are executed:

Server-side like PHP, NodeJS...
On the client side as Javascript...

These were some of the ways of classifying computer languages, I hope you have learned a lot. See you soon.

Classification of computer languages (II)

Valentiina VP — Mon, 13 Apr 2020 23:43:26 +0000

Continuing with the previous post , the following classification of programming languages is by paradigms. If you want to see the whole thread of this post, here I leave the table of contents:

Content
Classification Part I
Classification Part III

Paradigms

A programming paradigm is a methodology or programming philosophy to follow with a central core unquestionable, that is, the languages that use the same programming paradigm will use the same basic concepts to program.

Paradigms Groups
Imperative : Programmer indicates how to obtain the desired result.
Declarative: Programmer indicates what he wants to obtain the desired result.

Imperative paradigm

The code consists of a series of steps or instructions for performing a task organizing or changing values in memory. The instructions are executed sequentially, until the previous one is not executed, the next one will not be executed. Examples: Java, C, C ++, PHP, Javascript, Visual Basic...

Within this group are different programming methodologies. Among them, the structured methodology and the object-oriented methodology.

Structured methodology

At the end of the 70s, this methodology was born which allowed 3 types of structures in the code:

Sequential.
Alternative (based on a decision).
Repetitive (loops).

The structured program theorem states that each computable function can be implemented by combining structures sequentials, alternatives or repetitives.

Using these structures, encodings like the one in the image on the left can be replaced with a structured code like the one in the figure on the right:

The structured methodology evolved by adding the module as a basic component giving rise to structured and modular programming.

The programs were made up of modules or processes on the one hand and data on the other. The modules needed input data to get output data which in turn could beused by other modules. Example: C.

Module: independent code that performs a specific task.

With this evolution of structured programming methodology, it was possible to divide the problem into several subproblems that they can be solved separately and by joining them they get a final result.

It is desirable that the modules have high cohesion and low coupling.
- Cohesion: measures the strength of the relationship between instructions for a given module.
- Coupling: is the level of independence there is between modules. Low coupling is normally a sign of a well-structured system and good software design.

Object Oriented Methodology

In the 80's it emerged the methodology oriented objects that considers the object as a basic element. It became popular in the early 90's. Examples: Java, C++, and Javascript supports this methodology, although it is natively based on prototype-oriented programming.

Object: Abstraction of real life objects, both physical and abstract. All these objects have a state and a behavior. Each object is an instance of a class.
- Reals: car, house, bed, animal, person...
- Abstracts: a notification, a search ...
Class: A class is a plane or mold from which individual objects are created.

Programs contain objects that relate to or collaborate with other objects of the same class or from other classes. The class is made up of attributes (data) and methods (processes).

The most fundamental concepts within this methodology are:

Encapsulation: Hide internal details of a class. Keywords within this concept are: Private, public, protected ...

Inheritance: subclasses can be declared that inherit the properties and methods of the parent class.

Polymorphism refers to the property by which it is possible to send syntactically equal messages to objects of different types. The only requirement that must be met by objects that are used in a polymorphic way is to know how to respond to the message sent to them. Let's try to give an example of this: all animals make a sound, but this sound is different depending on the type of animal that emits it. Everyone will inherit the emitSound method from the parent class, but each subclass will do it differently. Let's see it graphically.

The world of object-oriented programming is big, in another post, I will continue to cover this topic. For now, let's continue with our classifications.

Declarative paradigm

The form of coding in this paradgim contains a set of conditions, propositions, affirmations, constraints, equations, or transformations that describe the problem and detail its solution. The programmer has to think about the logic of the algorithm and not in the sequencies of steps to perform. There are also different groups within this paradigm.

Logic programming
Algebraic programming
Functional programming

Logic programming

This methodology emerged as a simple form of communication between humans and machines, unlike low-level languages, making use of mathematical logic, which is the simplest way for the human intellect to express and formally prove complex problems. The language by excellence within this methodology is Prolog.

Algebraic programming

Methodology used mostly in relational database query languages such as SQL or Maude. This language makes use of a collection of relational schema operations that is used to manipulate relationships. The result of an operation, in turn, is also a relation, which allows you to chain calculations by applying an operator to the result of a previous calculation. These operators are the ones used by relational algebra:

This is an example of using relational algebra with the unary SELECTION primitive operator in SQL.

Functional programming

This type of languages, manage their entire structure through functions. There are no loops, or repetitive structures, and instead the concept of recursion is used. They makes use of mathematical functions. The difference from functions in the imperative paradigm is that imperative functions can make changes to previously performed calculations. Example: Heskel, Miranda. Javascript is not purely functional but supports such methodology, as well as Perl, Python, Ruby or Rust.

There are concepts within this methodology:

First-class and higher-order functions: they are functions that can take other functions as arguments or return them as results.
Pure functions: have not side effects (memory or I / O). They are widely used in code optimization
Strict(eager) vs. Non-Strict(Lazy) evaluation: concepts that refer to how function arguments are processed when an expression is being evaluated.
Type systems: The use of algebraic data types and pattern matching makes manipulation of complex data structures convenient and expressive, the presence of strict type checks at compile time makes programs more reliable, while type inference relieves the programmer of the need to manually declare the types for the compiler.

We have learned a lot today about paradigm classification of some languages. In the next post we will continue with the last classification ways. See you soon.

Classification of computer languages (I)

Valentiina VP — Sat, 11 Apr 2020 18:49:01 +0000

Computer language allows communicate with the computer. It is made up of a set of symbols and words that follow some syntax rules, in the same way as it exists in natural languages. There is no classification adopted by the majority of the experts, there are big differences.

If you want to see the whole thread of this post, here I leave the table of contents:

Content
Classification Part II
Classification Part III

A possible classification would be the following:

Classification Computer Languages
Markup Languages: They allow to place marks, badges or signs in the text that they will be interpreted by applications or processes. (HTML, XHTML, XML, Markdown...)
Specification or style languages: They are languages that they specify the presentation or style of a document written in one of the aforementioned markup languages. (CSS, XSL-FO, DSSL...)
Query languages: They allow to extract or manipulate data from a group of information.(SQL, CQL, XQUERY, DMX)
Transformation languages: They act on an initial information to obtain another new. (XSLT, TXL, DMS...)
Programming languages: They allow communication with hardware devices so that we can carry out a certain process. For this they can handle data structures stored in internal or external memory, and use control structures. They have a lexicon, and they have to follow rules syntactic and semantic. (Java, Javascript, C, C++, C#, Python...)

On many occasions I have heard some web developers say that they "program" in programming language as HTML and CSS. This is incorrect, HTML and CSS are not programming languages, as we have seen. If you are one of those developers, don't say it again 😊.

Programming languages also have various forms of classification.

Distance to hardware.
Generations.
Programming paradigm.
Way of translating into machine language and to run.
Server-client architecture

Let's see it in more detail.

Classification of programming languages

Distance to hardware

Within this classification, there is another:

Low-level languages	High-level languages
It is based directly on the electronic circuits of the machine. Programs written for one machine cannot be used on others, that is, it is not cross-platform. (Machine languages and Assembly language.)	They tend to get closer to human language and separate of the internal knowledge of the machine, that's why they need to be translated into machine language. This translation makes execution slower than in low-level languages but without depending on the processor, they can be run in different computers. They are cross-platform languages (Modern programming languages)

Machine language is binary code (zeros and ones) and acts directly about hardware. It is the only language that does not need translation since the processor recognizes instructions directly.

Assembly language. Coding in assembly language is mnemonic, that is, uses labels to describe certain operations. It's just a translation of strings of 0 and 1 almost impossible to remember by names that allow you to identify the instructions. It is necessary to translate the assembly code into the machine language so that the processor recognizes the instructions.

This is an example of the 3 + 5 addition operation in assembly language, machine language and a general representation in high-level languages. The machine code is represented in hexadecimal for having a shorter representation.

By Generations

Five generations
1st generation (1GL): formed by the languages of programming used in the first computers: machine and assembler language.
2nd generation (2GL): formed by language macroassembler which is the assembly language combined with control and operating instructions of more complex data. Each computer model has a language own assembler different from the others, for which the program can only be used on the machine to which was scheduled. They are still used to program the cores (kernel) of operating systems and drivers of some devices (device drivers).
3rd generation (3GL): made up of most of today's high-level languages. The code is machine independent and language programming is similar to human language.
4th generation (4GL): made up of languages and environments designed for a very task or purpose specific as access to databases, report generation, interface generation user etc. For example: SQL, Informix 4GL, Progress 4GL.
5th generation (5GL): natural languages, formed for the languages in which the programmer sets the problem to be solved and the conditions to comply. Mechanisms that allow communication between people and machines through languages natural It is used in artificial intelligence, systems based on knowledge, expert systems, mechanisms of inference or natural language processing. Examples: Prolog, Smalltalk and Lisp.

In the next post, we will study the other classifications in more depth. See you soon.