# data[].attributes.attachment_link.readable_text
Comments are the non-executable lines. In other words, comments are those lines or statements in the program which will not be executed during the execution process. The compiler ignores the comments automatically in the program. Comments are very useful to the developer while he writes the code in the program. It is a part of each program. Comments give details about the code in the program.

If the developer wants to give some messages, then he uses comments in the program.

It gives the details about the source code, which are readable by a normal human. This information also helps in maintaining the code in the program. It also helps in debugging the bugs.

In the go language, comments are used to provide the developer details about the variable, functions control structures, and any specific line of code or statement in the program. This information is very useful in the maintenance of the codes.

There are many features of comments; these help the developer in writing the source code. Few features of the comments are given below:

1. It is a non-executable statement in the program.

2. The compiler and interpreter both ignore the comments in the program during the compilation process.

3. It gives information about the variables and functions which are used in the program.

4. It helps the developer to find out the error in the program.

5. It helps the developer in clean coding.

6. Comments are readable by a normal human, which have a basic knowledge of computer.

There are three types of comments in the go language, which are given below:

1. Single line comment

2. Multiple line comment

3. Documentation comment

It is very clear by its name as this comment is for a single line.

When the developer writes the comment in a single line, it is known as a single-line comment. The single-line comments always start with double forward slashes, i.e.,//.

When you put double forward slashes (//) in front of any line or statement in the go program, then this statement will convert in the comment. These comments are used to describe a specific line.

You can put double forward slashes (//) anywhere in the program. Where you put these slashes, codes, or words will be covert into the comment from that place to the end of the line.

Syntax:

Example:

Here, the basic example of printing a string in go language with the single line comment is given below:

Output:

It is also clear by its name that this comment will be in multiple lines. It is also known as GoLang block comments or multi-line comments. If your comment exists in more than one line in the program, it is known as multiple line comments.

In multiple line comments, the comments always start with a single forward slash followed by a star sign like /* and end with a star sign followed by a single forward slash like */. The compiler or interpreter will ignore the content written in between these symbols.

The developer uses these comments when he needs to provide some information about the codes in the program. You can also use multiple line comments anywhere in the program.

Note:

Although there is a different syntax for writing the multi-line comments, the developer can also write multiple line comments with single-line comments. If he uses single-line comment syntax to write multiple line comment, then every line of the comment will start with double forward slashes (//).

But making the multi-line comments in this way is foolish to work. Adding a double forward slash in front of each line is not the correct way and a waste of time; it is unnecessary to add the slashes in each row if you have a better way to do the same.

Syntax:

Example:

Here, the basic example of printing a string in go language with the multiple line comment is given below:

Output:

It is a comment that is used by the developer at a higher level, basically in the development of the projects. It is used to provide some basic information to the user regarding the use of the application.

This comment creates the documentation API for the codes in go language. To create this API in the project, you require the go doc tool. The "go doc" tool generates a go documentation API; later, this API is used to provide the documentation comment to the user in the form of an HTML page. The documentation comment includes the HTML mark up and the texts on the page.

Go doc tool provides a web server to the user. To start a web server, first of all, you need to run the following command:

8331 is just a port number; you can also change this port number according to your requirements. After running the command, you can open the server on your browser by running the URL "localhost:8331" in your URLs bar.

Single line and multiple line comments are used in each program to provide information to the developer about the codes. In contrast, the developer uses documentation comments to provide the information to the user as a reference; it helps API users understand the codes written by another developer.

# data[].attributes.attachment_link.title
Comments in the Go program - Tutorial And Example

# data[].attributes.attachment_link.description
Comments are the non-executable lines. In other words, comments are those lines or statements in the program which will not be executed during the execution process. The compiler ignores the comments automatically in the program. Comments are very useful to the developer while he writes the code in the program.

# data[].attributes.attachment_link.readable_text
GoLang tools play an essential role when it comes to design a web application. It helps a lot in the coding section of the project.

Apicompat tool:

Apicompat is an important tool of the go language. This tool helps the developer in detecting the incompatible changes and backward in the go program. It also checks the exported declarations in the program. It avoids false positives. If any false positive is detected, then it will be reported as an error. Apicompat uses the golden masters for the testing of the source codes. Earlier it was named abicheck, which later on changed to Apicompat.

Since it is the Golang tool, so there are also some cons available in this tool. It cannot handle each backward. Sometimes it fails in detecting the changes in incompatible backward.

Currently, Apicompat is under heavy development process. In the initial version, only proof of concepts and shortcuts were considered. Now the current development is focused on the other functions of go language like adding doc files, flow charts, improve the output, and many more.

Checkstyle tool:

This one is yet another important tool of the go language. The go language checkstyle tool is inspired by the java checkstyle and the go language's golint tool. In the go language, this tool prints out the coding style suggestions. It also allows the go developer to check the file line-function and file line-param number.

There are some alternatives to the checkstyle tool also. These alternatives tools are:

Depth tool:

It is also an important tool for the go language. This tool is meant to facilitate the web developers in retrieving and visualizing the source code dependency trees in the go language. The depth tool can be used in your project as a particular package. You can also use this tool as a stand-alone command-line application. It allows you to add customization very easily to your program.

Go Swagger tool:

Go swagger is designed from the impression of swagger 2.0, and the go swagger can serialize and DE-serialize the functions of swagger 2.0. Go swagger tool provides the complete suite of GoLang feature to the developer. The tool brings the API components to work with swagger API, i.e., server, client, and date model.

Features:

1. It provides the code generation for the go program.

2. It also provides API generation based on swagger specifications.

3. It extends the string format.

4. It provides great customization of features in the go program.

This one is another important tool of the go language. You can use the go meta liner tool as a substitute for the go lint tool. If you are required to use the go-lint tool and normalize the output, you can simply do it with the help of the go meta liner tool.

You can use the go meta liner tool with a text editor or integrate with an IDE like you can use Sublime text with Sublime linter plug-in, Atom with a go-plus package, Vim/Neovim, and go for Visual Studio Code. It supports a large number of linters and their configuration files, the same as JSON.

Grapes tool:

The Grapes is a very light weighted tool of the go language. This tool is mainly designed for distributing the commands over SSH (secure shell, use to establish secured and encrypted communication between two hosts) without any difficulty. The Grapes tool of the go language is developed by Yaron Sumel and is currently maintained by him.

The Grapes tool is not gaining the developers' attention at the current time, and it is under the maintenance process for enhancing its functions and features.

Go Simple tool:

As its name suggests, it is a very simple but important tool of the go language. The main feature of the go simple tool is that it simplifies the go source code on the priority level. In all its functionality, it mainly focuses on simplifying the source code of your go program.

The go simple tool always supports the latest version of the go language. If the new version of the go language releases and your current version is outdated, then the go simple tool will suggest to you the easiest and the simplest way to ignore the complicated constructions in your go program.

Currently, the go simple tool works efficiently with the go version 1.15.

Go-Revive tool:

Go-revive is one of the most important tools of the go language. The developer uses this tool to enhance his workflow in the development of a project. The revive has the facility to configure itself. It is a fast and extensible tool of the go language.

The go-revive tool brings some unique, useful and developer-supported features to the table, making it more popular among the developers. Even the glint is very famous in the Go developers' society, but the go-revive tool provides approx. Six times faster speed than golint in running a go program. It also provides more features in comparison to golint.

Gaia tool:

Gaia is another powerful tool, which is used to create large and heavy pipelines. It can design the pipelines in any language, but it is specially used in the go language. It creates the pipelines with the help of DevOps. Gaia enables DevOps and allows the developer to develop powerful pipelines.

The Gaia tool has one more important feature; it has a cloning facility. It can clone the code repository, compile the code, and execute it whenever the developer requires it.

Although it has amazing features, there are some drawbacks, and still, it is not recommended for the complex and critical jobs in the alpha version.

Gotest tool:

The gotest is a tool that is used to generate the go tests in the program. It generates the go tests from the source code of your go program. It makes it easier for the developer to write the go tests.

The gotest is the go language's command-line tool, which is used in generating the table-driven tests based on functions and method signatures available on its target source file.
Note:
There are a lot of tools available for the go language. It is not possible to discuss all the important tools on a single desk. The importance of the tool can be different for individual developers. The importance of the tool mainly depends on the developer's requirements.

# data[].attributes.attachment_link.title
Tools for the Go language - Tutorial And Example

# data[].attributes.attachment_link.description
GoLang tools play an essential role when it comes to design a web application. It helps a lot in the coding section of the project. Apicompat is an important tool of the go language. This tool helps the developer in detecting the incompatible changes and backward in the go program.

# data[].attributes.attachment_link.readable_text
In C++, a multimap is similar to a map with the additional concept, where multiple elements possess the same keys. It is also not necessary that the key values and mapped values must be unique. The scenario is different in the case of multimaps. In a multimap, keys are always found in sorted order. This ordered property makes it difficult for competitive programmers to implement multimaps.

Moreover, multi maps are associative containers that are formed by combining key-value and mapped value, which is usually sorted or is in a specific order. Elements in multimap may sometimes have equivalent keys.

A multimap has key values, which are generally used to sort and uniquely identify elements, and the mapped values store the definitions or function related to this key. Some differences in the key and mapped value may exist, which later is grouped forming pairs by combining both.
Syntax
Here,

Key: It identifies each element by key value. Keys can be different.

T: It identifies each element by mapped value. Mapped values may be different.

There are various functions associate with mulimaps. Some of them are as follows:

begin() - It returns first element from the container while iteration.

end() - It returns the last element from the container while iteration.

size() - It returns the size or say number of elements present.

max_size() - It returns maximum number of elements an iterator can hold.

empty() - checks whether multimap is empty.

pair<int,int> insert(keyvalue,multimapvalue) - It is used to insert new elements in the multimap.

There are still plenty of such functios present the C++ STL . We may now see some basic coding examples and algorithms working behind it.
Output:

Explanation:

The above code explains how to map the key values associated with multimap. In the above code, we have taken arguments in the two forms i.e. integer and string to assign keys of Professors. We can visualize the output. Once the mapped values are sorted in ascending order and later in descending order, it gives us the idea that the mapped and key values can highly be useful for the data present in the form of arrays where we want to find the redundant values associated with them.

Note: The defined map provides a comparison operator in the map declaration to order the indexes. It provides a default comparison for the data type. In the example above, we can see that the key type is an integer with (=) operator and (<) operator can easily operate.

Let's us now take a straight forward look to the other functions present through the data table below.

constructor

It constructs multimap.

destructor

It destroys/removes multimap.

Iterators (cbegin, cend, rbegin, rend,crbegin, crend)

These functions manipulate the multimap using iterators from beginning to end and also in reversee order.

Capacity (empty, size and max_size)

These functios check size, maximum size and elements present or not.

Modifiers (erase, insert, clear, swap, emplace)

These functions are used to erase, insert, remove or clear, exchange or insert new elements by hint.

Observers (key_comp, value_comp)

Return copy of key comparison and value comparison.

Allocator (get_allocator)

Returns allocator used to construct the multimap.

Operations (count, upper_bound,lower_bound, find, equal_range)

Returns the element and the iterator with keys, counts, value of upper and lower bounds and matches elements with given key.

Advantages of using Multimap

The advantages are listed below:

It is comfortable to run through a multimap with iterators rather than using nested for-loop for the map and vector case.

Once we had inserted a value into the multimap, we know that the iterator would remain valid until we remove it. This is a very strong property; we can't have it with the map of vectors.

The value once inserted into a multimap remains valid until we remove it which is an added advantage over preferring a map of vectors.

In multimap, to get elements of a key and map of vectors we simply use [] operator and can have a vector of elements.

# data[].attributes.attachment_link.description
In C++, a multimap is similar to a map with the additional concept, where multiple elements possess the same keys. It is also not necessary that the key values and mapped values must be unique. The scenario is different in the case of multimaps. In a multimap, keys are always found in sorted order.

# data[].attributes.attachment_link.readable_text
The stack is a very popular data structure. It is the form of data structure that follows a particular order called FIFO(First-In-First-Out). In simple words, a stack is an Abstract Data Type used to store a collection of objects.

Various operations are uniquely associated with stacks. They are namely push, pop, and peek.

Push: When an element is pushed inside a stack, it is called Push

operation.

Pop: When an element is removed from the top of the stack, it is

called as Pop operation.

Peek or Top: This return top element of the stack.

isEmpty: It return true if stack is empty, else return false.
Pre-Requisites:
Before understanding stacks, one must be familiar with the below fundamentals.

1. Conditional statements like if, else.

2. Pointers.

3. Loops like for, while and do while.

4. Arrays and string primarily.

5. One object oriented programming language like C++ or Java.

All the above operations have 0(1) complexity and no loop is used.

Let us look at basic syntax of stack operations that we involve while implementing it.
Push: Pop:
Peek or Top:

isEmpty:

The above pseudo codes can be combined to show operations in the following code below.
Output:

Explanation:

In the above code, we have used an object-oriented programming method so that we can handle code complexity and make it more readable.

Let us take into consideration the below algorithms to understand the logic behind our code.

START
PUSH(STACK,TOP,MAX,ITEM)
B. Print "Stack full";

C. Exit out of the stack.

Otherwise

Top: = Top + 1; //increasing top

Check Stack(Top)= ITEM;

End IF

Exit

POP_STACK(STACK,TOP,ITEM)
A. IF Top = zero

Print "Empty Stack";

Exit;

ITEM: =Stack (Top);

Top:=Top - 1;

END

These algorithms are usually followed in the above code to show how the push and pop operations are commonly carried out.

Applications of Stacks

The applications of stacks are listed below:

The continuous memory blocks help in memory assignment when it takes place. With stack, we do it functionally and the size of the memory to be allocated will be already known by the compiler. When a functional call is executed, memory is allocated and de-allocated when it is already used. These executions happen at defined intervals so that the users do not have to worry about memory management.

Evaluating Expressions and Conversions:

Expressions in stacks primarily work on the operator precedence. Say (2*2)+4 will give us 8 since the * o r the parenthesis has higher priority. So, they can also be used for parenthesis matching in an expression when a user has not defined the correct order.

For complex algorithms like the 8 -Queens problem of Knights Tour problem, backtracking is specifically used to get to the last point where we found the value. Thus, a stack is very efficient in providing backtracking methods. It was used to get back from the current state we may need the previous state and then got into some other paths.
Insights:
In real-world applications, Stack plays a crucial role in particular. From the application perspective stacks are most applicable in the scientific calculations. The undo option in text editors use the stack to roll back to the previous elements.

In programming, it may be used to reverse a word, language processing, defining, and keeping records in a database, and also used to support recursion.

# data[].attributes.attachment_link.description
The stack is a very popular data structure. It is the form of data structure that follows a particular order called FIFO(First-In-First-Out). In simple words, a stack is an Abstract Data Type used to store a collection of objects. Various operations are uniquely associated with stacks. They are namely push, pop, and peek.

# data[].attributes.attachment_link.readable_text
Conditional processing means finding a solution between two given scenarios. suppose we have to distinguish or choose between two different options available, in order to deal with this situation COBOL have provided us with conditional operators to help us out in this situation
Set of conditional operators provided are :- IF-ELSE STATEMENT-

IF - ELSE statement is used to process data where we are required to make a certain selection between 2 or more objects.

For example, we have to file an income tax return on two income levels below 1 lakh. There will be a 5% tax, and above that, we have to pay a 10% tax to solve this type of condition, we have to use IF - ELSE statement.

IF AND ELSE can be used in different ways only if, if, and else together nested if-else. all the types have to be displayed below with examples for your better understanding

SYNTAX =>

1) only IF statement

2) IF ELSE statement

3) NESTED IF statements . using IF statements inside another IF statement
EXAMPLE 1) => EXAMPLE 2) => EXAMPLE 3) => EXAMPLE 4) => EXAMPLE 5) => EXAMPLE 6) => EXAMPLE 7) => EXAMPLE 8) => EXAMPLE 9) => SAMPLE PROGRAM -
THIS IS A DEMO PROGRAM TO LEARN AND UNDERSTAND THE CONCEPT OF IF-ELSE CONDITIONAL OPERATOR AND HOW DIFFERENT TYPES OF IF-ELSE OPERATORS CAN BE USED.
THE OUTPUT WILL BE

Here in this program, we have assigned few variables with different values and later by manipulating the output using different IF-ELSE conditions to clarify the different concepts related to IF AND ELSE operators and how numerous ways a simple IF - ELSE can be used.
EVALUATE STATEMENT-
In order to check for multiple statements, instead of using IF-ELSE we can use EVALUATE statements

SYNTAX =>
EXAMPLES =>
NOTE: - EVALUATE statement works on the basis of first come first serve basis and preference is always given to the statement stated first.

suppose if there are more than one conditions that are correct inside an evaluate statement, then the one which comes first from the top will be executed and the remaining will not be executed.

2)

3)

4)

5)
SAMPLE PROGRAM -
THIS IS A DEMO PROGRAM TO LEARN AND UNDERSTAND THE CONCEPT OF EVALUATE CONDITIONAL OPERATOR AND HOW DIFFERENT TYPES OF EVALUATE OPERATORS CAN BE USED.
THE OUTPUT WILL BE

--------------------------
THE OUTPUT WILL BE

Here in this program, we have assigned few variables with different values and later by manipulating the output using different EVALUATE conditions to make you clear about the different concepts related to EVALUATE operators and in how numerous ways a simple EVALUATE can be used.

# data[].attributes.attachment_link.title
COBOL Conditional Processing - Tutorial And Example

# data[].attributes.attachment_link.description
Conditional processing means finding a solution between two given scenarios. suppose we have to distinguish or choose between two different options available, in order to deal with this situation COBOL have provided us with conditional operators to help us out in this situation Set of conditional operators provided are :- IF-ELSE STATEMENT- IF - ELSE statement is used to process data where we are required to make a certain selection between 2 or more objects.

# data[].attributes.attachment_link.readable_text
The bubble sort algorithm is also known as the sinking algorithm. In this algorithm, we iterate over the array, and it takes two adjacent elements and swaps them if they are in the wrong order (ascending or descending). The step is continued until the whole array is sorted in a particular manner (ascending or descending).

Though the algorithm works poorly in real-world tools, due to its simplicity bubble sort algorithm is introduced as a primary tool when the algorithm concept is started. This algorithm takes a lot of time when the number of exchanges is more.

After each pass, the highest element is pushed to the last position. Similarly, the process is followed to push the second-highest number to the second last position and so on.

The first loop runs for (N-1) iterations. The second pass loop will run for (N-2) positions and so on.
Time complexity
Worst case: O(n^2)

Best case: O(n)

Average case: O(n^2)

Space complexity: O(1)

Example - let arr[] = {14, 33, 27, 35, 10} and n = 5

Pass 1
14 < 33 No swap takes place

Takes 33 and 27

Compares 27 < 23

After swap array becomes

Takes 33 and 35 compares to 33 < 35; no swap happens

Takes 35 and 10 compares 10 < 35

Swaps 10 and 35

After pass 1, 35 has reached its original place in the array that is the last index.
Pass 2
33 comes to its original place i.e, index 4.

Pass 3

Pass 4

C++ code: C code: Java code:

# data[].attributes.attachment_link.title
DAA: Bubble Sort Algorithm - Tutorial And Example

# data[].attributes.attachment_link.description
The bubble sort algorithm is also known as the sinking algorithm. In this algorithm, we iterate over the array, and it takes two adjacent elements and swaps them if they are in the wrong order (ascending or descending). The step is continued until the whole array is sorted in a particular manner (ascending or descending).

# data[].attributes.attachment_link.readable_text
Advantages of Jenkins

Jenkins is not the only option for continuous integration in the market; however, there are some other tools also available to do the same. But the Jenkins is more important and most widely used because of its use and amazing features. It would help if you spend some time studying Jenkins, and definitely, it will give you a lot of amazing features beyond your imagination. It is also known as the Heart of the DevOps pipeline. There are a lot of benefits of using the Jenkins pipeline; a few of them are given below:

1. Open Source and Free: Developers don't need to take tension about the money; it is free of cost. It is platform-independent.

2. Plug-ins and Integration: It is one of the most important features that make it most widely used. It has its type of plug-in, which helps the developer a lot in executing the jobs. Jenkins plug-ins can be developed by anyone and for anyone. Dashboard view plug-in, test analysis plug-in, build pipeline plug-in, and many more like this makes the developer familiar with the Jenkins tool.

3. Hosting Option: It is yet another important feature of the Jenkins, which can be installed on any operating system like Windows, MacOS, Linux, etc. You can also run Jenkins on the cloud by downloading and deploying it on a VM. You can also use a Docker container in it.

4. Community Support: Jenkins has great support from the developer community. You can assume its popularity and community support that it has more than 1000000 users all over the world, while it was officially published in 2011.

5. Integration with other CI/CD platforms: Jenkins supports many CI/CD platforms, not only the pipeline. It can make interaction with other tools also. Several plug-ins are available in it, which allows users to make connections with other CI/CD platforms.

6. Keep your team in sync: Jenkins focuses on a centralized way of working. All the members of the team move in sync.

7. Easy to debug: It is very easy to find out the errors in the Jenkins. The developer can easily check the bug and resolve it.

8. Less time to deliver the project: It happens because of its continuous integration feature.

9. Flexible in creating the jobs: It is very flexible in creating the jobs. It can create jobs both in freestyle and in the pipeline process very easily.

10. Source Code Management (SCM): Jenkins supports different types of source code repositories like SVN, Git, etc. The developer can set different trigger after making changes in the codes. He can do it every time.

11. It makes the process of converting in GUI from CLI very easy.

12. It provides accurate data support to project management.

13. It supports many languages, like Java, Python, etc.

Disadvantages of Jenkins:

Following are some cons of the Jenkins tool:

1. All plug-ins are not compatible with the declarative pipeline syntax.

2. Jenkins has many plug-ins in its library, but it seems like they are not maintained by the developer team from time to time. This is when it becomes very important that whatever plug-ins you are going to use; are getting a regular update or not.

3. Lots of plug-ins have a problem with the updating process.

4. It is dependent on plug-ins; sometimes, you can't find even basic things without plug-ins.

5. Jenkins UI is not user friendly in comparison to current UI Technologies. It cannot be very clear for the first-time user.

6. Managing of Jenkins dashboard is hard when we have too many jobs to be executed.

7. Changes made by a developer will not be visible to another developer of the team; only the manager can have its access. It makes tracking difficult in large projects.

8. Although many plug-ins are available, it does not provide the analytical support in the end to finish the deployment cycle. It leads to the creation of difficulties in the tracking of the project deployment.

9. The error message is not clear sometimes. It becomes hard to find out what went wrong.

10. You have to maintain your infrastructure by yourself.

11. It is not easy to install and configuration the Jenkins tool.

# data[].attributes.attachment_link.title
Advantages and Disadvantages of Jenkins - Tutorial And Example

# data[].attributes.attachment_link.description
Jenkins is not the only option for continuous integration in the market; however, there are some other tools also available to do the same. But the Jenkins is more important and most widely used because of its use and amazing features.

# data[].attributes.attachment_link.description
COBOL Arrays with tutorial and examples on HTML, CSS, JavaScript, XHTML, Java, .Net, PHP, C, C++, Python, JSP, Spring, Bootstrap, jQuery, Interview Questions etc.