Uncategorised

Details: Published: Tuesday, 17 September 2019 18:20; Hits: 3395

Signal processing refers to processing any i/p signal to generate a transformed o/p signal. The black box that does this transformation may be analog or digital circuit. The i/p, o/p signals may be continuous or discrete.

In Signal theory, we refer to signals as varying in time, (i.e signal F(t)). However signals can be function of any var "x" (i.e signal F(x)). It so happens that for any signal of interest in real scenario, x happens to be time "t". Although "t" is real, it can be complex too. Thus signal F(x) can be real or complex, with x itself being real or complex. As you can guess, in real world life scenario, signal F(x) is real.

Joseph Fourier proved that any periodic continuous function can be represented exactly via infinite sum of discrete sine and cosine waveforms. This series came to be known as Fourier series (FS). For non-periodic continuous signals, instead of discrete freq components of sine and cosine, it was a continuous freq spectrum, and came to be known as Fourier Transform (FT). This was very important discovery of 18th/19th century by Joseph Fourier, who introduced it for purpose of solving heat equations in a metal plate.

These are some good links for learning Fourier:

http://www.thefouriertransform.com/ => Superb explanation of fourier

Few imp formula before we get into FS:

1. freq in radian (ω) = 2Π*F = 2Π/T, where F = freq in hertz, T=time period in sec. Ex: linear freq of 1 Hz = 1 rotation/sec = 2*pi radians/sec = 6.28 radians/sec. This is very important formula to remember, as many textbooks compute Fourier in F, while many do it in ω. There is a constant factor 2Π that appears depending on whether you are dealing in Hz or radians.

2. Euler's formula: e^ix = cos(x) + i sin(x) => This is regarded as most remarkable formula in mathematics, as it establishes relationship b/w trignometric functions and complex exponential functions. "i" is defined as square root of -1 ( i = √-1 ) In maths, we use "i", but in physics, we use "j". Euler's formula can be proved easily, by writing taylor's expansion of exponential, and then separating it in 2 series, with 1 series corresponding to sin(x), while other series corresponding to cos(x). But it was Euler who saw it first.

3. Euler identity is Euler's formula with x=Π: e^iπ = cos(Π) + i sin(Π) = -1. For x=0 or 2Π, e⁰= e^i2π = cos(2Π) + i sin(2Π) = 1. From this, it implies that e^jω₀T₀= e^i2π = 1.

4. Complex number: Any complex number c=a+ib can be represented in magnitude and phase form. a+ib = mag.e^iθwhere mag = √(a² + b²), and tan(θ) = b/a. So, c=|c|.e^i∠c. This is how we'll represent complex numbers in signal theory.

5. Impulse function or delta dirac function: This is a hypothetical function which is 1 at t=0, but is 0 everywhere else. This can be thought of as a gaussian function, with limit t->0. i.e Limit t->0 ∫ x(t) dt =1, where x(t) is gaussian function. This impulse function is used extensively in signal theory, since mathematically impulse function allows conversion from cont domain to discrete domain. NOTE: x(t) is a continuous func. The resulting integral is the area of that func, and thus is a cont func of "t". As t->0, in continuous form, the value at t=0 approaches ∞ for impulse function, as base "x" axis time scale reduces to 0, to keep area = 1. in discrete form, impulse function is defined as x[n]=1 which is 1 at n=0, and 0 everywhere else.

Impulse function δ(x) defined as limit x->0 ∫ δ(x) dx =1

Just as we define impulse func at x=0, we can define it at any x=x₀. limit x->0 ∫ δ(x-x₀) dx =1. Here δ(x) is 1 at x=x₀, but 0 everywhere else. So, the gaussian func is just shifted from being centered at x=0, to being centered at x=x₀.

Few Sine/Cosine formula:

0. cos(x) = (e^ix + e^-^ix )/2 ; sin(x) = (e^ix - e^-^ix )/2i => derived by using Euler's formula above

1. sin(x) = cos(x-Π/2)

2. ∫ sin(2Πnt)*sin(2Πmt)dt = 0 for n≠m, and ∫ sin(2Πnt)*sin(2Πmt)dt = 1/2 for n=m. Here n, m are both integers, and limit of t is from 0 to 1

3. ∫ cos(2Πnt)*cos(2Πmt)dt = 0 for n≠m, and ∫ cos(2Πnt)*cos(2Πmt)dt = 1/2 for n=m. Here n, m are both integers, and limit of t is from 0 to 1

4. ∫ cos(2Πnt)*sin(2Πmt)dt = 0 for any n, m. Here n, m are both integers, and limit of t is from 0 to 1. These 3 eqn are used in proof of FS later.

Continuous time (CT) signals: here F(x) is a continuous function over all values of x, where -∞ < x < ∞. Fourier series or Fourier transform of CT signals is always aperiodic in freq domain.

1. Continuous Time Fourier Series (CTFS): For continuous and periodic signals in time domain, we can compute CTFS. This CTFS is discrete and aperiodic in freq domain.

Any cont periodic signal is represented as infinite summation of cos and sine functions. This is called FS representation of function. CTFS is the fundamental eqn, and all other series/transform for cont/discrete waveforms are derived from CTFS. CTFS is what was derived by Fourier, and is surprisingly very easy to prove.

x(t) = a₀ + ∑ a_k * cos(ω₀kt) + ∑ b_k * sin(ω₀kt) , where k = 1 to ∞. Here feq ω₀ = 2Π / T₀, where T₀ is the freq of periodic signal (1/T₀ = f₀). Here a₀ is the DC freq component, while ω₀ = fundamental or 1st harmonic, 2ω₀ = second harmonic and so on. Coefficients a₀, a_k, b_k are called Fourier coefficents, and are computed as follows. Integral is taken over 1 period of the periodic signal.

a₀ = 1/T₀ ∫ x(t) dt,

a_k = 1/T₀ ∫ x(t) cos(2Πkt/T₀) dt

b_k = 1/T₀ ∫ x(t) sin(2Πkt/T₀) dt

NOTE: This series contains only real terms, and is called real FS. k above is +ve, and goes from 1 to infinity. In reality, k = 0 to ∞. It just so happens, that for k=0, cos(2Πkt/T₀) =1, while sin(2Πkt/T₀) = 0. So, a₀ = 1/T₀ ∫ x(t) dt, while b₀ = 0. No -ve k allowed. From now on, we'll refer to FS coeff as {a_k, b_k} with k from 0 to ∞. The motivation for a₀is to provide dc offset, since all sine/cosine functions are always centered around X-axis with y=0 (i.e no dc offset, they start from 0 and go back to 0 over 1 cycle). In order to represent any offset from x-axis, we need a constant, which is what a₀ provides.

Also, x(t+T) = x(t) is true when calc thru FS, as ω₀T₀ = 2Π.

Proof: We can prove FS above very easily. Proof is presented very nicely here: http://faculty.olin.edu/bstorey/Notes/Fourier.pdf.

Let's assume that FS is true, and we can indeed rep any function as sum of sine and cosine.

x(t) = a₀ + ∑ a_k * cos(ω₀kt) + ∑ b_k * sin(ω₀kt)

Multiply both sides of eqn by sin(2Πmt), and then integrating over limit 0 to 1, we get values of a₀, a_k and b_k. So that implies that eqn above is true since we can get coeff which satisfy this eqn.

We can make above series simpler. We put, a_k = d_k cos(θ_k), b_k = d_k sin(θ_k). We can do this since any 2 numbers on x and y axis can be represented on a circle with a certain radius and angle.

x(t) = ∑ d_k cos(θ_k) * cos(ω₀kt) + ∑ d_k sin(θ_k) * sin(ω₀kt) = ∑ d_k cos(θ_k+ω₀kt) where d_k = √(a_k² + b_k²), and tan(θ_k) = b_k /a_{k ,} with k = 0 to ∞.

Above eqn is easier to work with. It shows that any function can be rep as cosine series only with different magnitude and offset for each freq component. This seems logical, since sine can be converted to cosine with 90 degree phase offset. Instead of representing series in cosine series only, we could represent it in sine series only (as it's just phase shift of 90 degrees). Though above series, whether in sine or cosine, is ok to work in maths, we prefer to work in complex exponential in physics. This makes it easier to solve them. So, we try to get it in Euler's form.

We use the formula: cos(θ) = (e^jθ + e-^jθ)/2 to convert real numbers to complex numbers. We also note that subscript k can be both +ve/-ve value. Substituting this, we get the below form:

x(t) = ∑ C_k * e^jω₀kt( -∞ < k < ∞ ), Here C_k is complex number = d_k/2 * e^jθ_k = 1/2 * {d_k cos(θ_k)₊ d_k j.sin(θ_k)}.

C_k = 1/T₀ ∫ x(t) e^-^jω₀ktdt, Integral is taken over 1 period of the periodic signal.

Magnitude of this complex number C_k is d_k/2 = √(a_k² + b_k²)/2, while phase is θ_k where tan(θ_k) = b_k /a_{k ,}

NOTE: This series contains complex terms, and is called complex FS. Here k is both -ve and +ve, so we have freq spectrum on both sides of x axis (while FS terms were only on +ve x axis). This is why we have a 1/2 multiplier factor when going from real FS to complex FS, to account for it existing on both sides (we half the magnitude on both sides, when converting cosine to complex exponential). Also, FS coeff have -ve term in exponent, while inverse FS (i.e reconstruction of original signal) has +ve term in exponent. This is going to be true in all series and transforms as we'll see later (though it could have been other way around too, this is just a convention ?? FIXME?).

From now on, we will work with complex FS only. It's easy to represent, as we can draw magnitude and phase plot of this one complex number (instead of having 2 real numbers a_k and b_k). This plot runs over all values of k, so we see this plot on both sides of x axis. The magnitude plot of C_k is symmetrical around x=0 axis, while phase plot of C_k is -ve of each other on 2 sides of x-axis. Note that even though C_k is complex, the fourier series sum can still yield real function.

We can calculate FS coefficients for a variety of periodic signals, and observe many interesting things about sinusoidal wave, square wave, triangular wave, etc. We'll discuss those later.

2. Continuous Time Fourier Transform (CTFT): For continuous and aperiodic signals in time domain, we can compute CTFT. This CTFT is continuous and aperiodic in freq domain. Non periodic signal can be considered as a special case of a periodic signal, where Time period T₀ is expanded to infinity, and we consider only 1 cycle of periodic signal.

We can derive FS for aperiodic signals (attach proof, FIXME). On deriving, we come up with below eqn: NOTE: factor T₀ goes away and gets replaced by (2Π) when deriving this.

x(t) = 1/(2Π) ∫ X(ω) e^jωtdω, where X(ω) is the CTFT of x(t). Integral is taken over full -∞ < ω < ∞. Only difference compared to CTFS is that ω₀k is replaced by ω, and infinite summation is replaced by integral. This is also called inverse CTFT.

X(ω) = ∫ x(t) e^-^jωtdt, Integral is taken over full time of the aperiodic signal -∞ < t < ∞. Note: this looks similar to C_k for periodic signals, except that C_k for aperiodic signals has become continuous now. Also, 1/T₀ is absent, as we folded that factor 1/(2Π) outside the integral in x(t) eqn above, so that it is no longer a part of FT. This is the forward CTFT. We can also write X(ω) as X(jω) so as to be explicit that ω is complex.

So, to conclude, we see that CT periodic signals have discrete freq at +/-ω₀, +/-2ω₀, +/-3ω₀ and so on. But CT aperiodic signals have a continuum of freq from -∞ < ω < ∞. Other way to see is that freq is kω₀ for both periodic and aperiodic. But for periodic, k can take integer values only (i.e 0,1,2,3, ..), but for aperiodic signals, k can take all real values (i.e, 0, 0.001, 0.002, ....). CTFT is a superset of CTFS, as we can calculate CTFT of both periodic and aperiodic signals. There is nothing that prohibits taking CTFT of periodic signals. CTFT of aperiodic signals yields cont freq spectrum as we saw above. However, for periodic signals, we saw that we get discrete values for C_k. Since CTFT is derived from CTFS, CTFT should also yield same answer. However, we saw that CTFT is cont, and integral can never yield non cont discrete values. Dirac delta function comes to our rescue here, as they allow discrete values to be represented as the limiting case of gaussian func. So, CTFT of periodic signals will yield impulse or dirac delta at discrete freq, so that the func remains cont. So CTFT will serve us well for all kinds of waveforms (both periodic and aperiodic). Going forward, we'll learn CTFT only.

NOTE: we derived FT in terms of ω, which gives us a factor of (2Π). If we derive FT in terms of f, then we get rid of (2Π).

X(2Πf) = ∫ x(t) e^-^j(2Πf)tdt => X(f) = ∫ x(t) e^-^j(2Πf)tdt => remains same as X(ω), as integral is done over "t" and not "f"

x(t) = 1/(2Π) ∫ X(2Πf) e^j(2Πf)td(2Πf) = 1/(2Π) * (2Π) ∫ X(2Πf) e^j(2Πf)td(f) = ∫ X(2Πf) e^j(2Πf)tdf => x(t) = ∫ X(f) e^j(2Πf)tdf => gets rid of factor 2Π compared to X(ω), as integral is over "f".

3. Laplace transform: LT is defined for CT signals, in exactly same way as FT is defined for CT signals. In LT, complex var "s" has both real and imaginary parts (s = σ + jω). FT happens to a special case of LT, with σ=0, so s=jω. LT and FT are kind of same. When dealing with signals, we use FT, while when dealing with systems, we use LT. LT allows us to solve ordinary differential eqn encountered in RLC ckt, in an easier way by transforming it from time domain to laplace "s" domain (we can solve it equally easily by transforming it to Fourier "jω" domain). We eventually end up substituting s with jω, so both LT and FT end up same.

LT[x(t)] = X(s) = ∫ x(t) e^-s^tdt, Integral is taken over full time of the aperiodic signal -∞ < t < ∞. This is called two sided LT. Since most signals are 0 for t<0, we usually evaluate integral from 0 < t < ∞. This is called one sided LT. Note: this looks similar to FT eqn above, except that jω is replaced by s.

Discrete time (DT) signals: here F{x[n]} is a discrete function over all values of n, where x[n] is the input signal with n=0, +/-1, +/-2, ... ∞. Fourier series or Fourier transform of DT signals is always periodic in freq domain. This is the main diff b/w CT and DT. Otherwise DT are similar to CT.

1. Discrete Time Fourier Series (DTFS): For discrete and periodic signals in time domain, we can compute DTFS. This DTFS is discrete and periodic in freq domain. It's similar to it's CT counterpart CTFS.

We can derive DTFS from CTFS.

First let's derive x[n] from x[(t):

For CTFS, x(t) = ∑ C_k * e^jω₀kt( -∞ < k < ∞ ). However, now x(t) is not continuous, but has discrete values. Assume N samples for x(t) equally spaced by T₀/N intervals, from t=0*T₀/N to t=(N-1)*T₀/N. So samples are x(0) to x((N-1)*T₀/N).

x(t=n*T₀/N) = ∑ C_k * e^{j(2Π/T₀)k(n*T₀/N)}( -∞ < k < ∞ ).

Represent discrete x(t) as x[n], where x[n] = x(n*T₀/N), and n = 0 to N-1.

x[n] = ∑ C_k * e^j(2Π/N)kn, Here summation is over 1 period of C_k(Need to find out how summation went from ∞ to one period). Since C_k is periodic with period N (as we'll see below), we choose k as 0 < k < N-1. It doesn't matter what values of k we take, as long as it represents one full cycle over N values. So, C_k may have total N samples from C₀ to C_N-1 . i.e 0 < k < N-1, or C₁ to C_N , i.e 1 < k < N, or any other period. This looks similar to CTFS, except that it has period ω₀ replaced by 2Π/N. T₀= 2Π / ω₀ = N.

Now, let's derive C_k for x[n] from C_k for x[(t):

For CTFS, C_k = 1/T₀ ∫ x(t) e^-^jω₀ktdt, However, since x(t) is not continuous any more, but has discrete values, we can't calculate integral. However, we can make approximation of this integral, by taking only those "t" for which values of x(t) is known.

Then we use same value of x(t) for interval T₀/N. So, x(t) at any time t is x(n*T₀/N) where n = 0 to N-1.

C_k = 1/T₀ ∫ x(t) e^-^jω₀ktdt ≈ 1/T₀∑ x(n*T₀/N) e^-^{jω₀kn*T₀/N} * T₀/N, where t=n*T₀/N, ans summation is over n=0 to N-1. We approximate each integral piece as a rectangular box with height=x(n*T₀/N) and width=T₀/N.

=> C_k = 1/N ∑ x(n*T₀/N) e^-^{j(2Π/T₀)kn*T₀/N}= 1/N ∑ x[n] e^-^j(2Π/N)kn, where x[n] = x(n*T₀/N), and n = 0 to N-1.

C_k = 1/N ∑ x[n] e^-^j(2Π/N)kn, summation is over 1 period of the periodic input signal with period=N samples, i.e 0 < n < N-1. C_k is complex number, and is periodic. with 0 < k < N-1. C_k is periodic can be deduced from the fact that for k=0 or k=N, C₀= C_N as e^j(0) = e^j(2Π) . This looks similar to CTFS, except that it has summation instead of integral and C_k is periodic with period N.

Proof here: https://www.math.ubc.ca/~feldman/m267/dft.pdf

2. Discrete Time Fourier Transform (DTFT or DTF): For discrete and aperiodic signals in time domain, we can compute DTFT. This DTFT is continuous and periodic in freq domain. It's similar to it's CT counterpart CTFT.

We can derive DTFT from DTFS, the same way we derived CTFT from CTFS (by treating summation as integral when T -> ∞)

x[n] = 1/(2Π) ∫ X(ω) e^jωndω, where X(ω) is the DTFT of x[n]. Integral is taken over 1 cycle of ω, i.e λ < ω < λ+2Π. Only difference compared to CTFT is that t is replaced by n, and integral over all values of ω, is replaced by integral over 1 cycle of ω. This is also called inverse DTFT.

X(ω) = ∑ x[n] e^-jωⁿ, summation is taken over all samples of the aperiodic signal -∞ < n < ∞. Note: this looks similar to CTFT, except that t is replaced by n, and integral is replaced by summation, Also, X(ω) is periodic now, since X(ω+2Π) = X(ω). This is also called forward DTFT.

Since, same X(ω) notation is used for both CTFT and DTFT, it can cause confusion, as to whose FT is it representing (discrete or continuous). So, we for DTFT, we write it as X(Ω) or X(e^jω), while for CTFT, we write it as X(ω) or X(jω).

CTFT: X(ω) or X(jω) = |X(jω)|e^i∠X(jw).

DTFT: X(Ω) or X(e^jω) = |X(e^jω)|e^i∠X(ejω).

3. z transform (ZT): ZT is defined for DT signals, in exactly same way as LT is defined for CT signals. It is same as DTFT, except that complex var "z" is of form Ae^jω. DTFT is special case of ZT, where complex var "Ω" is of form e^jω (i.e z with unit magnitude only).

ZT{x[n]} = X(z) = ∑ x[n] z^-ⁿ, -∞ < n < ∞. This is same as DTFT with z=e^jω.

ZT is used to solve discrete diff eqn in time domain. Concept is same as that of LT for solving cont diff eqn in time domain.

----

Discrete Fourier Transform (DFT):

This is a very popular topic in any signals theory. When we talk about anything in DSP (digital signal processing), DFT is what we are talking about. As we saw above, we can take DTFT of discrete signals which are not periodic. Since in real life, most signals are not periodic and are sampled, DTFT is what we use mostly for discrete signals (instead of DTFS). Computers can work with discrete signals (samples of analog signals at discrete times), and process them to generate DTFT of those samples. However, DTFT that we get above is itself continuous, and that is a problem for machines that deal with discrete samples only. Computers can't generate analog DTFT waveform. They can generate samples of DTFT. We can generate samples of DTFT so close by that we can approximate analog DTFT signal. Those samples of DTFT are called DFT.

DTFT of x[n] = X(Ω) = ∑ x[n] e^-jωⁿ,

DFT of x[n] = X_k or X[k] = samples of X(Ω) at discrete freq = X(Ω) | _ω=2Πk/N where 0 <= k <= N-1. Here we are taking N samples, X₀ to X_N-1

But discrete freq components implies periodic x[n], since only periodic signals can have discrete freq components. As we saw above, DTFS has discrete freq components, while DTFT has continuous freq spectrum. Basically as signal becomes aperiodic (or T -> ∞), more and more freq components start showing up, until it becomes continuous freq spectrum.

So, if we try to reconstruct original signal x[n] by taking inverse DFT of X_k_, we'll not get original x[n], but periodic x[n]. As we have more and more samples of X_k, we'll get more and more original values of x[n] with larger period (i.e T starts going to ∞). So, DFT of x[n] is basically same as taking DTFS of periodic x[n].

DTFS of x[n] = C_k = 1/N ∑ x[n] e^-^j(2Π/N)kn

DFT of x[n] = X_k or X[k] = 1/N ∑ x[n] e^-^j(2Π/N)kn = 1/N ∑ x[n] e^-^jω_kn , where ω_k=2Πk/N where 0 <= k <= N-1.

Thus DFT of x[n] can be calculated by either of 2 ways:

1. Compute DTFT of x[n]. Then take samples of DTFT at discrete freq ω_k=2Πk/N where 0 <= k <= N-1.

2. Compute DTFS of x[n]. This DTFS gives same result as 1 (taking DTFT samples) above.

Inverse DFT of X_k = x[n] = ∑ X_k e^jω_kⁿ, where ω_k=2Πk/N where 0 <= k <= N-1.

This is same as inverse DTFS = x[n] = ∑ C_k * e^j(2Π/N)kn, where 0 <= k <= N-1.

Thus from now on, we'll treat DFT the same as DTFS. So, when we say DFT, we mean DTFS, and not DTFT.

Details: Published: Monday, 16 September 2019 22:21; Hits: 2790

vlsi digital standards

There are many standards for diffeent files used in vlsi. We talk about some standards and their formats:

LEF:

DEF:

UVM:

...

Details: Published: Monday, 16 September 2019 22:08; Hits: 2216

Webserver: Any website that you access, goes to a computer on internet. On that computer is a program running (for linux it's apache) which allows that computer to return the response back to the client. This computer is called a webserver. Before we get into webserver program, let's get some basics.

IP addr:

Each device connected to internet is assigned a unique 32 bit IP addr. These are written as 4 octets(each octet is 8 bits) - e.g. 18.251.48.77. IP addresses can go from 0.0.0.0 to 255.255.255.255. However, IP adr are divided into 5 classes based on addr range:

class A: 1.0.0.0 - 127.255.255.255 => Top 8 bits are Net ID. Bottom 24 bits are Node ID.

class B: 128.0.0.0 - 191.255.255.255 => Top 16 bits are Net ID. Bottom 16 bits are Node ID.

class C: 192.0.0.0 - 223.255.255.255 => Top 24 bits are Net ID. Bottom 8 bits are Node ID.

class D: 224.0.0.0 - 239.255.255.255 => multicast. Top 4 MSB are "1110". Remaining 28 bits are Multicast ID.

class E: 240.0.0.0 - 255.255.255.255 => experimental, reserved for future use

Public vs Private: IP addr can be public or private.

The following ranges are reserved by the Internet Assigned Numbers Authority (IANA) for use as private IP addresses:

10.0.0.0 to 10.255.255.255 => from class A
172.16.0.0 to 172.31.255.255 => from class B
192.168.0.0 to 192.168.255.255 => from class C. All of the 192.x addr are not registered publically, so they can only be used behind a router as private IP addresses. This range is where most private IP addresses fall, which is why the default IP address for most Linksys, D-Link, Cisco, and NETGEAR routers is an IP within this set.

Any other addr besides the private ones listed above are available for use as public IP addr. Public IP addr are the ones that can be accessed by any device connected to internet. Each device connected to internet has 1 uniue public IP addr. A device finds some other device on internet by knowing their public IP addr, and using routers to route to that device. private addresses are non-routable — hardware devices on the internet are programmed to prevent devices with a private IP address from communicating directly with any other IP beyond the router that they're connected to. Private IP addr are not unique. Devices in my home and neighbours home can have same private IP addr.

Home Router:

Home routers have 2 or more n/w i/f (or port) each with it's own IP addr. One i/f connects to Wired internet lines coming to your house. There is usually a modem inbuilt in the router which provides this i/f. This i/f has public IP addr that can be seen by the whole world. This public ip addr is assigned to your router by your ISP provider (AT&T, Spectrum, etc). The ISP provider usually keeps on changing this public addr assigned to your router. That is why you may see diff IP addr of your router on diff days. All other i/f of router are the wired or wireless i/f with their private ip addr. All computers in the house also have their own private IP addr. Thus, behind the router, all devices talk to each other using their private IP addr. These same private ip addr can also be present behind your neighbour's routers. But since when trying to connect to private ip addr, the router never allows the traffic for private ip addr to leave the router, there is no source of confusion b/w your home's private n/w traffic and your neighbor's private n/w traffic, since none of this traffic ever leave their respective router, if it's meant for a device on same n/w.

If you try to find IP addr of your computer, use the "ifconfig" cmd on a terminal in Linux.

ifconfig: interface configuration. Used to view and change the configuration of the network interfaces on your system. It is run at startup to configure network interfaces of your computer. Usually, there are 3 n/w i/f for your computer = wired ethernet, wireless and loopback. Ethernet i/f has name "eth", loopback has "lo" while wireless has "wlan". Names may differ for diff Linux distro. All i/f show 32 bit IP v4 address, and 48 bit IP v6 address / 48 bit mac physical address. If Ethernet i/f is connected, we'll see ip addr assigned as 192.168.1.57. Loopback i/f shows ip addr as 127.0.0.1. If we have a web server running on our computer, and if we type 127.0.0.1 in our browser, it doesn't goto any other computer, but loops back on same computer and shows main index page (this is useful in debug). Wireless i/f shows IP addr as "inet: 192.168.1.70". NOTE: ethernet i/ and wireless i/f have their own IP addr, which are not same. So, depending on which IP addr you use, you connect via ethernet or wireless to that device.

NOTE: ethernet and wireless i/f show that the computer is assigned a private ip addr from class C, while loopback i/f shows private ip addr from class A. Both addr are private addr. So, if we have webserver running on our computer, we could type 192.168.1.70 in our browser, and it will behave same as loopback, i.e it will show http main index page on our own computer,

On CentOS, you may see more than 1 wireless n/w i/f even though the computer has 1 n/w card. These are virtual n/w switch/bridge with names as virbr0 (virtual bridge 0), etc. These are used by certain applications on your m/c. These virtual i/f can be disabled or removed w/o any effect (except for the pgm using it).

Note: What we got above is the private ip addr of our computer. We don't know the ip addr of other devices talking to our computer. Next, let's try to find IP addr of our modem/router:

route: route cmd shows the kernel routing table entries, and also allows us to edit the table. This is the table that is used by OS for static routing. It's primary use is to set up static routes to specific hosts or networks via an interface after it was configured with the ifconfig program.

> route => route cmd shows below o/p. The flag U indicates that route is up and G indicates that it is gateway.
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         homeportal                 0.0.0.0         UG    600    0        0 wlp3s0
192.168.1.0     0.0.0.0         255.255.255.0       U     600     0        0 wlp3s0
192.168.122.0   0.0.0.0         255.255.255.0     U     0         0         0 virbr0

route -n => this shows gateway IP addr number instead of names.

Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         192.168.1.254   0.0.0.0                UG    600    0        0 wlp3s0
192.168.1.0     0.0.0.0         255.255.255.0      U     600    0        0 wlp3s0
192.168.122.0   0.0.0.0         255.255.255.0   U    0      0        0 virbr0

From above o/p, we see that if a packet comes into the system (i.e this laptop) and has a destination in the range 192.168.1.0 through 192.168.1.255, then it is forwarded to the gateway 0.0.0.0 (also represented as * on some systems) — a special address which represents an invalid or non-existant destination. So, in this case, our system will not route these packets. Same is the case with ip addr 192.168.122.0 to 192.168.122.255.

If the destination is not in this IP address range, it is forwarded to the default gateway (in this case, 192.168.1.254 which is the router), and that system will determine how to forward the traffic on to the next step towards its destination. 192.168.1.254 is the private IP addr of the router (router has public ip addr also, which is on the other i/f). If we type this addr in browser, 192.168.1.254, we'll see out login menu for the router show up (this page is the http index page of router that it's shipped with).

Details: Published: Monday, 16 September 2019 21:42; Hits: 1303

C Shell (csh) or tcsh:

C shell was created by Bill Joy of UCB in 1978, shortly after release of sh shell. It was developed to make coding style similar to C language (since C was the most used language for programming at that time), and make it easier to use. Later a improved version of csh called tcsh was developed which borrowed a lot of useful concepts from Tenex systems, hence the "t". On most linux systems, tcsh is the shell used (even though it says csh, it's actually tcsh, as csh is usually a soft link to tcsh binary).

NOTE: Even though we say csh everywhere, it's really tcsh that we are talking about. Extensions still say *.csh. We'll call it csh even though we mean tcsh.

This is offcial website for tcsh: https://www.tcsh.org/

This is good website for all shell/linux related stuff: (The guy lists a lot of reasons on why csh shouldn't be used): https://www.grymoire.com/Unix/Csh.html

Bill Joy's csh intro paper here: http://www.kitebird.com/csh-tcsh-book/csh-intro.pdf

csh syntax: https://www.mkssoftware.com/docs/man1/csh.1.asp

NOTE: C shell is not recommended shell for usage. Bash is the one that should be used. Almost all of linux scripts, that you find in your linux distro, are in bash. Csh is introduced here, since some scripts in corporate IT world are still written in csh, which you may need to work on from time to time. Csh is ripe with bugs, and you can find a lot of articles as to why Csh should not be used. One reason why csh is so buggy and unpredictable is because it doesn't have a true parser like other shells. Bill Joy famously admitted that he wasn't a very good programmer when he wrote csh. To make matters worse, there is no elaborate documentation of csh (unlike bash, which has very detailed documentation on tldp.org website). The only doc that shows up most frequently on internet searches is that "bill Joy's csh" paper, whiich is like decades old (shown in link above). This makes it hard to systematically learn csh. What I've documented below is just bits and pieces from diff websites, as well as my own trial and error with csh cmds. In spite of all this, csh became so popular, which just bewilders me. Hope, I've convinced you enough not to read thru the csh doc below.

Csh startup files: uses 3 startup files:

1. .cshrc: It's sourced everytime a new C shell starts. The shell does a "source .cshrc". csh scripts also source this file, unless "-f" (i.e fast) option is used on cmd line or on 1st line of csh script

ex: #!/bin/csh -f => -f option as 1st line of script causes csh to startup in fast mode, i.e it reads nether the .cshrc nor the .login

2. .login: If you are in a login shell, then this file is the 2nd file sourced. after the .cshrc file.

3. .logout: This is the last executed on logging out (only from a login shell)

Simple csh script example: similar to bash, except for 1st line. Save it as test.csh.

#!/bin/csh -f

echo "hello"; => this cmd followed by args. Each line of csh is "cmd followed by args"

Run this script by doing "chmod 755 test.csh", and then typing ./test.csh.

csh itself has many options that can be provided on cmdline that controls it's behaviour.

ex: csh -f -v -x ... => many more options possible. -x is an important option that echoes cmds immediately before execution (this is useful for debug)

Csh Syntax:

csh is very similar to C in syntax. Similar to bash, we'll look at reserved keywords/cmds, variables and special char. On a single line, different tokens are separated by whitespace (tab, space or blank line). The following char don't need space to be identified as a separate token: &, &&, |, ||, <, <<, >, >>, ;, (, ). That's why many special char such as + need space around them since w/o a space, csh is not able to parse it into a token.

As in bash, each line in csh is a cmd followed by args for that cmd. Separate lines are separated by newline (enter key), semicolon (;) or control characters (similar to bash).

A. Commands: similar to bash, csh may have simple or complex cmds.

1. simple cmd: just as in bash, they can be built in or external cmd. Few ex:

alias: same as in bash, but syntax little different. Alias are usually put in initialization files like ~/.cshrc etc so that the shell sees all the aliases (instead of typing them each time or sourcing the alias file). One caveat to note is that Aliases are not inherited by child processes, so any csh script that you run will not inherit these alias until you redefine these alias again in your script.
- ex: alias e 'emacs'. => NOTE no "=" sign here (diff than bash where we had = sign). Now we can type "e" on cmd line and it will get replaced by emacs and so emacs will open.

2. complex/compound cmd: They are cmds as if-else, while, etc. They are explained later.

B. Variable: csh needs "set" cmd to set variables, unlike bash which just uses "=". Everything else is same. $ is used to get value of a variable assigned previously. There are 2 kinds of var: global and local var

1. local var: local vars are assigned using set and "=" sign, i.e set var = value. NOTE: we can use spaces around = sign, unlike bash where no spaces were allowed. This is because "set" keyword is the assignment cmd, and rest is arg, so spaces don't matter. In bash, the whole assignment thing was a cmd.

set libsdir = "/sim/proj/"$USER"/digtop_$1" => spaces around = sign. $ inside double quotes or outside, is always expanded.
echo "myincalibs = " $libsdir => prints: myincalibs = /sim/proj/ashish/digtop_abcd

2. global var: For global var, we need to use "setenv" and no = sign. i.e: setenv HOME /home/ashish. No separate "export" cmd needed (as in bash). setenv cmd by itself does export too, so that the var is accessible to subshells. To see list of global var, we can use cmd "setenv" by itself with no args (we can also use env and printenv cmds from bash). Most of the global vars such as HOME, PATH, etc are same as those in bash.

setenv RTL_FILES "${DIGWORK}_user/design/svfiles.f" => {} allows the var inside braces only to be used for $ subs. NOTE: no = sign. setenv (rather than set) is used for global var (we used setenv so that this variable can be used in other scripts running from same shell).

$? => this checks for existence of a var. i.e $?HOME will return 1 (implying var exists), while $?temp123 will return 0 (implying var doesn't exist). This has different meaning in bash, where it expands to exit staus of most recently executed foreground pipeline. So, $?HOME will return 0HOME if the cmd run just before this was a success, or return 127HOME if cmd run just before this was in error, where 127 is the error code

prompt: Terminals with csh usually show a "%" sign as prompt. setting prompt in csh is same as setting other global vars. To set prompt in csh, we use keyword prompt instead of PS1. However, prompt keyword itself doesn't work in many c shells.

echo $prompt => on my centos laptop when in csh, it shows "%%[%n@%m %c]%#"
set prompt = " $cwd %h$ " => doesn't work at some corporations, as csh is actually tcsh (even though echo says its /bin/csh, installed pkg are always tcsh as tcsh is improved version of csh, and csh is just a soft link to tcsh), so use tcsh cmds. tcsh is backward compatible with csh, but somehow this cmd doesn't work. So, correct way would be:
set prompt = "[%/] > " => this worked on m/c, but not guaranteed to work on others.

Data types: variables can be of diff data types. Looks like as in bash, primitive data types here are char string.

1. String: Everything is char string. It's internally interpreted as integer numbers depending on context.

ex: set a=12; set b=13; @ c= $a + $b; echo $c will print 12 +13=25 since it will treat those 2 var as integer. @ is special cmd used to assign a calculated value. For + to be treated as an arithmetic operator, there has to be space on both sides of +, else it will error out. NOTE: it doesn't use "set" cmd to assign a arithmetic calculated value.

ex: set a=12; set b=13; set c=$a+$b; echo $c will print "12+13", since it will treat the whole thing on RHS as a string (those 2 var and + are all string). NOTE: it uses "set" cmd here for string assignment.

ex: set d=jim => this assigns a string "jim" to var "d" even though it's not enclosed in double quotes. We would have needed to use single or double quotes if we had special char inside the RHS string as space, $, etc.

2. array: array contains multiple values. syntax same as in bash. However, here index start from 1 instead of 0 (in bash, index start from 0). Also, assciative array don't seem to work in csh.

ex: my_array=(one two three) => this assigns my_array[1]=one, my_array[2]=two and so on.

ex: echo $my_array[2] => this prints "two" even though curly braces are not used. Not sure why this works. NOTE: in bash, echo ${my_array[2]} was needed to print correctly. So, to be on safe side, always use curly braces around var to remove ambiguity. "echo $my_array[0]" would print nothing as there is no index 0.

ex: echo $my_array => this would print all array, i.e "one two three", unlike bash, where it prints just the 1st element of array, i.e "one"

ex: set my_array[2]=one => If we do "echo $my_array[2]" it will print "one" as the array got overwritten at index=2.

ex: set me[1]="pat" => this doesn't work, as arrays can only be assigned via ( ... ). We can later change the value of any index of array using this syntax, but we can't define a new array using this. If we do "echo ${me[1]}" then it gives an error "me: Undefined variable" as csh looks for array "me" defined using parenthesis ( ... ) and tries to get value for index=0. In this case, "me" was never defined to be an array

ex: my_array[name]='ajay'; => associative array don't work in csh

C. Special Characters or metacharacters: This is mostly same as in bash. cmd line editing in bash was basically taken from csh, so all cmd line edit keys from bash work in csh.

special character usage: special char are mostly same as in bash.

1. # => comment. This is single line comment. If you want to comment multiple lines, use "if" cmd explained later. As explained in "bash" scripting section, comment line is not completely ignored in csh, in contrast to bash. The "\" character at the end of comment line is looked at to figure out if the newline at the end of comment should be escaped or not. Comment is still ignored. So, very important to carefully look at any comment line, and put a backslash at end of it, if a regular cmd there would have needed a backslash. Look at backslash description in bullet 2 below. Let's look at an ex below:

ex: foreach dirname ( dir1 \

dir2 \

#dir3 \

)

In above ex, dir3 is commented out and has a "\" at end. So, the whole line until "\" is ignored. "\" at end escapes newline, so contents of next line are treated as part of same line. This is how it looks after expanding:

foreach dirname ( dir1 dir2 ) => Here "dir3" is completely ignored as it's in comment except for "\" which causes continuation of line 4 (closing barces) on line 3 itself. NOTE: \ at end is NOT continuation of comment, i.e it's not like this: foreach dirname ( dir1 dir2 #dir3 ) => this would have caused an error as closing brackets won't be seen by csh interpreter. This is not what happens in csh.

ex: The below ex causes a syntax error "Too many ('s". This is because closing bracket ) is seen on another line, so it's like this foreach dirname ( dir1 dir2 => so ) is not on same line resulting in error.

foreach dirname ( dir1 \

dir2 \

#dir3

)

2. " ' \ => same as in bash, they hide special char from shell.

I. Double Quotes " " : weak quoting

II. Single Quotes ' ': strong quoting

III. Backslash \ : hides all special characters from the shell, but it can hide only one character at a time. So, it can be used to hide newline character at end of line by putting backslash at end of line (this allows next line to be seen as part of current line). There is slight variation to this for the comment line as shown in example above (backslash at end of comment line is not seen as continuation of comment line).

3. End of cmd: Same as in bash, a newline character (by pressing enter/return) is used to denote end of 1 cmd line. For multiple cmds on same line, semicolon (;) can be used to separate multiple cmd. There has to be a space after semicolon, else parser will not see ; as a token.

Control operators: Same as in bash. Pipe cmd and list work same way.

4. source or . cmd: same as in bash

5. backquote or backtick (`): same as in bash. However, the o/p here is stored in an array, instead of a simple string

ex: a=`ls`; echo $a; => This will print the array a (as o/p of this is stored in array). To see individual elements of array, we can do $a[1], $a[2]. etc (NOTE: $a[0] is not valid as arrays start with index=1 in csh)

6A. user interaction: All languages provide some way of getting i/p from a user and dumping o/p. In bash, we can use these builtin cmds to do this:

Output cmds: echo cmd supported.

Input cmds: csh has "$<" for reading i/p.

ex: below cmd reads i/p from terminal and prints the o/p

echo -n Input your number:

set input = $<

echo You entered $input

6B. IO redirection: same as in bash.

7. Brackets [ ] , braces { } and parenthesis ( ) : same as in bash. [] and {} are used in pattern matching using glob. All [], {}, () are used in pattern matching in BRE/ERE. See in regular expression section. However, they are used in other ways also:

I. single ( ) { } [ ]:

( ) { } => these are used to group cmds, to be executed as a single unit. parenthesis (list) causes all cmds in list to be executed in separate subshell, while curly braces { list; } causes them to be executed in same shell.

{ } => Braces { } are also used to unambiguously identify variables. They protect the var within {} as one var. { ..} is optional for simple parameter expansion (i.e $name is actually simplified form of ${name})

{ } can also be used for separate out a block of code. spaces should be used here. ex: a=3; { c=95; .... } echo $c;

[ ] => square brackets are used for globbing as explained above.

[ ] are also used to denote array elements as explained in array section above.

arithmetic operators: One of the most useful feature of csh, which is missing in bash, is that csh allows direct arithmetic operations. No "expr" cmd needed to do numeric arithmetic. These arithmetic operations can appear in @, if, while and exit cmds. Many of these operators below return boolean "true" or "false", but there is no inbuilt boolean type. i.e if (true) ... is invalid. An expr has to be used that evaluates to true or false.

number arithmetic: +, -, *, /, %, **(exponent), id++/id-- (post inc/dec), ++id/--id (pre inc/dec)
bitwise: &, |, ^(bitwise xor), ~(bitwise negation), <<(left shift), >>(right shift). ~ is also used as expansion to home dir name.
logical: &&, ||, !(logical negation)
string comparison: ==(equality), !=(inequality), These are not arithmetic comparisons but lexicographical (alphabetic) comparisons on strings, based on ASCII numbering. Here RHS has to be a string and not a pattern.
<=, >=, < ,>. => these operate on numbers (unlike bash, where these operate on string, and -lt, -ge, etc were used instead to compare numbers)
assignment: =(assigns RHS to LHS), *=, /= %= += -= <<= >>= &= ^= |= => these are assigments where RHS is operated on by the operator before =, and then assigned to LHS (i.e a*=b; is same as a=a*b.
matching: =~ this is a matching operator (similar to perl syntax) where string on RHS is considered ERE, and is matched with string on LHS. ex: [ $line =~ *?(a)b ] => returns true if string contains the pattern
- seems like .* for ERE is not honored, but rather just plain * as used in glob. ex: $name =~ raj_.* doesn't match raj_kumar, but $name =~ raj_* (w/o the dot) does match raj_kumar
non matching: !~ this is non matching operator, where string on RHS is considered ERE. returns true if strings doesn't contain the pattern.
condional evaluation: expr ? expr1 : expr2 => similar to C if else stmt
comma : comma is used as separator b/w expr

ex: @ c=$a + $b; => @ needed to do arithmetc. No "set" cmd needed.

ex: @ num = 2 => this assigns numeric value 2 to num. If we used "set num = 2" then it assigns num to string 2. It may then still be interpreted as num or string depending on how it's used later.

ex: @ i++ => increments var i by 1

ex: if ($a < $b) echo "a < b"

II. double (( )) {{ }} [[ ]] => no known usage in csh

8. pattern matching: same as in bash

9. looping constructs: These 2 cmds used to form loops: foreach and while. "break" and "continue" builins are used to control loop execution, and have same behaviour as in bash. break exits the loop, not the script. continue continues the loop w/o going thru the remaining stmt in loop that are after continue.

foreach: It's a loop where the variable name is successively set to each member of wordlist and the sequence of commands until the matching end statement are executed. Both foreach and end must appear alone on separate lines. syntax:
- ```
foreach name (wordlist)
         commands
     end
```
- ex:
```
foreach color (red orange yellow green blue)
        echo $color
     end
```

while: Just like foreach, it's a loop Statements within the while/end loop are conditionally executed based upon the evaluation of the expression. Both while and end must appear alone on separate lines.syntax:

while (expression)
         commands
     end

ex: set word = "anything"
     while ($word != "")
       echo -n "Enter a word to check (Return to exit): "
       set word = $<
       if ($word != "") grep $word /usr/share/dict/words
     end

break / continue: these are used in foreach or while loop statements above. "break" terminates execution of loop, and transfers control to stmt after the end stmt, while "continue" transfers control to the end stmt. So, "break" forces the pgm to exit the loop, while "continue" keeps on continuing with next iteration of loop (while skipping stmt in the loop that come after continue).
- ```
foreach number (one two three exit four)
       if ($number == exit) then
         echo reached an exit
         break (or use continue. break takes ctl to stmt right after "end" stmt, while continue takes it back to beginning of loop, to start with next iteration)
       endif
       echo $number
     end
```

10. Conditional constructs: same as in bash, syntax slightly different. Also these are closer to C lang in syntax, and have switch.

if-else: There are 2 variants of if cmd: A. if without else B. if with else
- if => if (expr) command [arguments] => here cmd must be a simple cmd, not piped cmds. There is no else clause.
  - ex: if ($#argv == 0) echo There are no arguments => all in one line
  - ex: if (-d $dirname) echo "dir exists" => this checks for existence of dir. options supported for existence of files/dir are same as those in bash
- if-then-else => if (expr) then (cmd1) else (cmd2) endif . There may be multiple else clauses here. "then" and "endif" are required in this form of if-else.
  - ```
  ex: if ($number < 0) then  
             @ class = 0  
          else if (0 <= $number && $number < 100) then  
             @ class = 1      
          else  
             @ class = 3  
          endif
```
- if ($dat == $vrfir) then => Note no semicolon used. == used (as in C)
  echo foo
  else => optional
  echo bar!
  endif
- if-then may be used for multi line comments. ex: set debug=1; if ($debug == 1) then ........ endif
- if (!(-e ${AMS_DIR}/net.v)) then ... else ... endif => checks for existence of a file. same options as in bash.

switch case: The switch structure permits you to set up a series of tests and conditionally executed commands based upon the value of a string. If none of the labels match before a `default' label is found, then the execution begins after the default label. Each case has "breaksw" cmd at end of case that causes execution to continue after the endsw. Otherwise control may fall through case labels and default label may execute if there is no "breaksw". Also, the patterns for each case may contain ? and * to match groups of characters or specific characters. syntax is as follows:
- ```
switch (string)
  case pattern1:
    commands...
    breaksw
  case pattern2:
    commands...
    breaksw
  default:
    commands...
    breaksw
endsw
```
- ```
ex: if ($#argv == 0 ) then
        echo "No arguments supplied...exiting"
        exit 1
     else 
        switch ($argv[1])
        case [yY][eE][sS]:
          echo Argument one is yes.
          breaksw
        case [nN][oO]:
          echo Argument one is no.
          breaksw
        default:
          echo Argument one is neither yes nor no.
          breaksw
        endsw
     endif
```
goto: The goto statement transfers control to the statement beginning with label:
- ```
     if ($#argv != 1) goto error1
     goto OK
     error1:
       echo "Invalid - wrong number or no arguments"
       echo "Quitting"
       exit 1
     OK:
       echo "Argument = $argv[1]"
       exit 1
```
- if (.$RUN == ams) goto ams_run
  ....
  ams_run: => control transferred here
  ....
  exit
- goto is usually used to print usage info of a script when number of args is insufficient
  if ($#argv < 3) then
  goto usage
  else ... endif => process cmd line args
  usage:
  echo " shows usage of cmd" => This prints usage info for that script when cmd is typed
  exit

Advanced csh cmds: Read on csh links on top for more on this.

Details: Published: Monday, 16 September 2019 21:33; Hits: 2343

programming vs scripting languages

There are many different general purpose programming and scripting languages. Over the past decade, languages have exploded (both traditional languages and scripting languages, both referred to as programming languages now), and it's hard to even know where to start. There are 2 categories of languages: one is the traditional general purpose programming language as C, while other is scripting language as python.

1. general purpose programming languages: compiles in a binary code, and then binary is executed, so it's fast. Languages like C are an example of GP programming languages. C has been the most popular programming language since it's start in 1970. Almost every software big or small was coded in C, and it was the ONE language that everybody learned. Even today it's the most popular language used to build OS, desktop software, large enterprise systems, etc.

2. scripting languages: they are usually not compiled, but are interpreted at runtime by an interpreter. i.e they are read line by line, and then at end of each line, that line is translated to binary code to run on the computer. So they are slow to run. But now with such fast machines, for most of the user programs, scripts run almost as fast as compiled code. Scripting languages used to be very limited in scope (i.e they weren't meant for general programming, but as quick replacement to write simple scripts to do something), but things have changed now. Scripting languages have the same functionality as complex compiled languages, and are much easier to learn. Many of them are GP programming languages.

The lines have now blurred, and all languages whether compiled or interpreted are referred to as GP programming languages.

Which Language to learn?

There are so many programming and scripting languages out there, that it's intimidating. Which language should you learn and how much? Should you go for depth, i.e learn just one language, but learn it deep? Or should you go for breadth, i.e learn multiple languages, but not in too much depth? My philosophy is that you should never spend too much time going in depth, because that takes from you the ability to learn multiple things.

C, Java and Python are the 3 most popular languages as of 2020.

https://fossbytes.com/most-popular-programming-languages/

C has always been the most popular language, but since it's harder to learn for beginners, it's likely to lose it's top spot. Java is heavily used in software companies, and a huge driver for that is Android platform from google that supports Java. However, python is rapidly gaining popularity, because it's much easier to learn. In fact, more universities now teach Python in their introductory courses. Java is reserved for Advanced courses. If you have resource to learn one and only one language, I would strongly suggest learning Python.

There are many other languages that you will need to learn, since Python alone can't do everything. For ex, if you looking to build a website, you will need to know a little bit of HTML and CSS, and then use it with Python. Another ex is that of a database language as MySQL. You will need to know little bit of MySQL so that you can integrate it with Python. We'll go thru all of these in next sections.

This is an essential list of programming languages that will suffice most of your needs:

Website Laguages: Learn HTML, CSS. Then learn Javascript for client side scripting and Php for server side scripting

Database Language: SQL is the Database language. MySQL is a software using SQL, but MySQL is usually referred to as the Language itself (they are tightly integrated with each other) It's mostly used in Web applications, and knowing at least 1 Database Language is a must.

Desktop Applications: C, Java and Python will suffice here. These are traditional GP programming languages that you write programs in, on your laptop to build a game, app, etc.

NOTE: If you are trying to learn a language to get a job, I've no clue of which language to learn. However if you re looking to learn a langauge to solve your own problem, to code your own program or just to have fun, then any language will do just fine, provided it's easy to learn. Python just fits all of that.

Resources: Below I'm going to list few excellent websites for learning coding. they are all free, and a lot of material that I've on my website, is based of these:

1. Tutorials Point => https://www.tutorialspoint.com

This is a very good website for learning any language or computer science courses. They are arranged very well, and have fantastic tutorials with lots of examples. They are based in India, and what's impressive is that they have covered almost everything in their vast tutorials library.

2. Geeks For Geeks => https://www.geeksforgeeks.org

This is another excellent website for learning anything computer science related. Although it says it's for geeks, I've found that their tutorials are very simple for beginners to learn. What I like is that they have divided their tutorials into different sections based on complexity, so you can just learn what suffices you. One shortcoming is that their library is not as vast as that of Tutorials Point, but they do have tutorials for all popular languages that we care about.

3. Digital Ocean => https://www.digitalocean.com/

This is not really a tutorials website, but a site for selling products. However, I bumped into it while trying to find a good tutorial on Javascript, and was amazed by the quality of the material. There is a tutorials section on this site, which is mainatined by a very active community. It has about 4K tutorials.

https://www.digitalocean.com/community/tutorials

It may be hard to find what you are looking for, since searching for something like "javascript" returns about 400 tutorials. However, what I've found is that they have tutorial "series", and depending on who wrote it, they may provide you the best tutorial out there. For ex, searching for html, shows me a "Series: How to build a website with HTML" => this is what you want to read. You need to read the whole series from start to end, so that you get the whole tutorial.

Conclusion: I'll add more websites as I come across more of them. There are some hugely popular websites as www.w3schools.com, or a language's official website, but most of the times that contain great reference material for the language, but don't really have great tutorials. You need to look elsewhere most of the times, and once you have some basic idea of a language, you can come to these official websites, and they will make a lot more sense.

The main thing to remember is not any one website has best tutorials for everything. Also, depending on who wrote it, the quality of tutorials may vary. Some are very good writers, and you might want to stick to tutorials of those writers on a given website. However, what I've found is that these websites try to maintain a consistent writing style, so that's good.

Nav view search

Navigation

Search

More Articles ...