computer science major

Computer science major 

Boolean Types

A Boolean is every other kind of variable that is used to keep a fact value, either real orfalse, of a logical statement. Some programming languages explicitly assist a constructed-inBoolean type at the same time as others implicitly support them. For languages which have explicitBoolean types, typically the key phrases genuine and false are used, however logical expressionssuch as x ≤ 10 can also be evaluated and assigned to Boolean variables. 

Some languages do not have an specific Boolean kind and as an alternative guide Booleansimplicitly, from time to time by means of using numeric types. For instance, in C, fake is related withzero even as any non-0 fee is associated with proper. In either case, Boolean values areused to make choices and manage the float of operations in a application (see Chapter 3). 

Object & Reference Types 

Not the whole lot is a range of or string. Often, we wish to model real-global entities suchas humans, places, accounts, or even interactions such as exchanges or transactions.Most programming languages can help you create user-described types via the usage of objects orstructures. Objects and structures can help you organization a couple of portions of statistics togetherinto one logical entity; that is referred to as encapsulation. For example, a Student item mayconsist of a primary-call, ultimate-name, GPA, year, primary, and so on. Grouping those separate piecesof statistics together allows us to define a greater complex kind. We explore those ideas inmore intensity in Chapter 10. 

In contrast to the built-in numeric, man or woman/string, and Boolean kinds (also calledprimitive records types) user-defined types do now not always take a fixed amount of memoryto represent. Since they're user-described, it's far as much as the programmer to specify howthey get created and the way they're represented in reminiscence. A variable that refers to anobject or shape is often a reference or pointer: a reference to where the item isstored in reminiscence on a laptop. Many programming languages use the keyword null(or once in a while NULL or a a few variant) to suggest an invalid reference. The nullkeyword is frequently used to consult uninitialized or “missing” records. 

Another common consumer-defined type is an enumerated type which allows a user to define alist of key phrases related to integers. For example, the cardinal guidelines, “north”,“south”, “east”, and “west” could be related to the integers zero, 1, 2, three respectively.Defining an enumerated type then lets in you to apply those key phrases on your programdirectly while not having to rely upon mysterious numerical values, creating a program morereadable and much less at risk of blunders. 

2.2.Three. Declaring Variables: Dynamic vs. Static Typing 

In some languages, variables need to be declared before they can be mentioned or used.When you declare a variable, you no longer simplest give it an identifier, but additionally outline its kind.For example, you may claim a variable named numberOfStudents and outline it to bean integer. For the lifestyles of that variable, it will usually be an integer kind. You can onlygive that variable integer values. Attempts to assign, say, a string type to an integervariable may also both result in a syntax blunders or a runtime errors when the program isexecuted or lead to sudden or undefined behavior. A language that calls for you todeclare a variable and its type is a statically typed language. 

The announcement of a variable is commonly achieved by writing a declaration that includesthe variable’s type (the usage of a integrated key-word of the language) in conjunction with the variablename. For example, in C-fashion languages, a line like 

int 

x;would create an integer variable associated with the identifier x . 

In other languages, normally interpreted languages, you do now not have to declare a variablebefore using it. Such languages are usually known as dynamically typed languages.Instead of putting forward a variable to have a specific type, the form of a variable isdetermined by way of the form of value that is assigned to it. If you assign an integer to avariable it turns into an integer. If you assign a string to it, it will become a string type.Moreover, a variable’s type can exchange in the course of the execution of a software. If you reassigna value to a variable, it dynamically adjustments its kind to match the kind of the valueassigned. 

In PHP for example, a line like$x = 10;could create an integer variable related to the identifier $x . In this case, wedid not declare that $x became an integer. Instead, it became inferred by means of the fee that weassigned to it (10). 

At first look it may appear that dynamically typed languages are better. Certainlythey are extra flexible (and can help you write much less so-called “boilerplate” code), butthat flexibility comes at a price. Dynamically typed variables are commonly less efficient.Moreover, dynamic typing opens the door to a whole lot of ability type mismatching mistakes.For example, you may have a variable that is assumed to continually be an integer. In adynamically typed language, no such assumption is legitimate as a reassignment can changethe variable’s kind. It is impossible to implement this assumption by using the language itself andmay require a lot of more code to test a variable’s type and address “type protection”issues. The benefits and downsides of every remain debated. 

2.2.Four. Scoping 

The scope of a variable is the segment of code in which a variable is legitimate or “recognised.”In a statically typed language, a variable must be declared earlier than it is able to be used. Thecode block in which the variable is asserted is therefore its scope. Outside of this codeblock, the variable is invalid. Attempts to reference or use a variable that is out-of-scopetypically bring about a syntax error. An example the use of the C programming language isdepicted in Code Sample 2.1. 

Scoping in a dynamically typed language is similar, however since you don’t claim a variable,the scope is normally described by using the block of code where you first use or reference thevariable. In some languages using a variable can also reason that variable to become globallyscoped. 

A globally scoped variable is valid all through the whole thing of a application. A global variablecan be accessed and referenced on every line of code. Sometimes this is a good aspect:as an example, we may want to outline a variable to symbolize π after which use it anywhere in ourprogram. We could then be assured that each computation involving π might be usingthe equal definition of π (in preference to one line of coding using the approximation 3.14while another makes use of three.14159).  

On the same token, however, worldwide variables make the kingdom and execution of a programless predictable: if any piece of code can get admission to a global variable, then doubtlessly anypiece of code should exchange that variable. Imagine some questionable code converting thevalue of our worldwide π variable to a few. For this reason, the use of international variables is generallyconsidered horrific practice.5 Even if no code plays such an egregious operation, thefact that whatever can alternate the price approach that when checking out, you ought to check for 

the ability that something will change the price, substantially increasing the complexityof software program testing. To capture the benefits of a worldwide variable whilst fending off thedisadvantages, it's far commonplace to simplest allow international constants; variables whose values cannotbe modified once set. 

Another argument in opposition to globally scoped variables is that when the identifier has beenused, it cannot be reused or redefined for different functions (a floating factor variable withthe identifier pi approach we cannot use the identifier pi for another motive) asit would cause conflicts. Defining many globally scoped variables (or features, orother elements) starts to pollute the namespace by means of reserving more and more identifiers.

Problems stand up while one attempts to apply more than one libraries which have each used the sameidentifiers for specific variables or functions. Resolving the battle can be tough orimpossible if you have no manipulate over the offending libraries.

It is crucial to recognise that once this notation is used, it isn't always an algebraic declarationlike a = b which is an algebraic announcement that the variables a and b are identical. Anassignment operator is distinctive: it way area the value on the right-hand-aspect into thevariable at the left-hand-aspect. For that motive, writing something like 

is invalid syntax. The left-hand-aspect must be a variable.The proper-hand-aspect, but, may be a literal, every other variable, or maybe a more complexexpression. In the example earlier than, 

the cost 10 was acting as a numerical literal: a way of expressing a (human-readable)price that the laptop can then interpret as a binary fee. In code, we will convenientlywrite numbers in base-10; whilst compiled or interpreted, the numerical literals areconverted into binary statistics that the pc knows and positioned in a memorylocation corresponding to the variable. This entire technique is automatic and transparentto the person. Literals can also be strings or other values. For example: 

message ← “hiya world”We can also “copy” values from one variable to another. Assuming that we’ve assignedthe value 10 to the variable a, we can then replica it to some other variable b:b ← a 

This does now not mean that a and b are the equal variable. The value that is saved in thevariable a at the time that this assertion is carried out is copied into the variable b. Thereare now two unique variables with the equal cost. If we reassign the value in a, thevalue in b is unaffected. This is illustrated in Algorithm 2.1 

1 a ← 102 b ← a//a and b both keep the price 10 at this point3 a ← 20//now a has the fee 20, but b nevertheless has the value 104 b ← 25//a still shops a value of 20, b now has a fee of 25 

Algorithm 2.1:  

Assignment Operator DemonstrationThe right-hand-side also can be a more complex expression, as an example the end result ofsumming two numbers collectively

2.Three. Operators 

Now that we have variables, we need a way to work with variables. That is, given twovariables we can also desire to feature them collectively. Or we may also wish to take  strings andcombine them to shape a new string. In programming languages that is accomplishedthrough operators which operate on one or extra operands. An operator takes the valuesof its operands and combines them in some way to produce a new price. If an operatoris carried out to variable(s), then the values used inside the operation are the values saved inthe variable on the time that the operator is evaluated.

Many common operators are binary in that they operate on two operands inclusive of commonarithmetic operations like addition and multiplication. Some operators are unary in thatthey handiest function on one variable. The first operator that we observe is a unary operatorand permits us to assign values to variables. 

2.3.1. Assignment Operators 

The task operator is a unary operator that lets in you to take a value and assignit to a variable. The mission operator typically takes the following shape: the price i splaced at the proper-hand-side of the operator while the variable to which we are assigningthe fee is located at the left-hand-side of the operator. For our pseudocode, we’ll use ageneric “left-arrow” notation:

which need to be read as “place the fee 10 into the variable a.” Many C-fashion seasonedgramming languages typically use a unmarried equal signal for the venture operator. Theexample above is probably written as