DEV Community: Mani Sai Prasad

Introduction to HTTP in a Nutshell

Mani Sai Prasad — Fri, 18 Dec 2020 11:17:53 +0000

Hypertext Transfer Protocol (HTTP) is a protocol that provides a standardized way for computers to communicate with each other. It has been the foundation for data communication over the internet since 1990 and is integral to understanding how client-server communication functions.

Features of HTTP

Connectionless
When a request is sent, the client opens the connection; once a response is received, the client closes the connection. The client and server only maintain a connection during the response and request. Future responses are made on a new connection.

Stateless
There is no dependency between successive requests. Each request is an individual request

Not Sessionless
Utilizing headers and cookies, sessions can be created to allow each HTTP request to share the same context.

Media Independent:
Any type of data can be sent over HTTP as long as both the client and server know how to handle the data format. In our case, we'll use JSON.

Elements:

Universal Resource Identifiers (URIs):
An example URI is https://github.com/manisaiprasad?tab=repositories It has certain components:

Scheme:
specifies the protocol used to access the resource, HTTP or HTTPS. In our example HTTPS.

Host:
specifies the host that holds the resources. In our example github.com.

Path:
specifies the specific resource being requested. In our example, /manisaiprasad.

Query:
an optional component, the query string provides information the resource can use for some purpose such as a search parameter. In our example, tab=repositories.

HTTP Requests

HTTP requests are sent from the client to the server to initiate some operation. In addition to the URL, HTTP requests have other elements to specify the requested resource.

Elements of HTTP Requests:

Method: Defines the operation to be performed

Path: The URL of the resource to be fetched, excluding the scheme and host

HTTP Version

Headers:
optional information, success as Accept-Language

Body: optional information, usually for methods such as POST and PATCH, which contain the resource being sent to the server

Request Methods

Different request methods indicate different operations to be performed. It's essential to attend to this to correctly format your requests and properly structure an API.

GET: ONLY retrieves information for the requested resource of the given URI

POST: Send data to the server to create a new resource.

PUT: Replaces all of the representation of the target resource with the requested data

PATCH: Partially modifies the representation of the target resource with the requested data

DELETE: Removes all of the representation of the resource specified by the URI

OPTIONS: Sends the communication options for the requested resource

HTTP Responses

After the request has been received by the server and processed, the server returns an HTTP response message to the client. The response informs the client of the outcome of the requested operation.

Elements of HTTP Responses:

Status Code & Status Message

HTTP Version

Headers: similar to the request headers, provides information about the response and resource representation. Some common headers include:

Date

Content-Type: the media type of the body of the request

Body: optional data containing the requested resource

Status Codes:

As an API developer, it's important to send the correct status code. As a developer using an API, the status codes—particularly the error codes—are important for understanding what caused an error and how to proceed.

Codes fall into five categories:

1xx Informational (100's)
2xx Success (200's)
3xx Redirection (300's)
4xx Client Error (400's)
5xx Server Error (500's)

Common Codes:

200: OK
201: Created
304: Not Modified
400: Bad Request
401: Unauthorized
404: Not Found
405: Method Not Allowed
500: Internal Server Error

Ghost on Heroku

Mani Sai Prasad — Wed, 19 Aug 2020 01:00:02 +0000

Ghost is a free and open-source blogging platform written in JavaScript and distributed under the MIT License, It a simple and a powerful platform to share your content

Visit the project's website at http://ghost.org, or read the docs on http://support.ghost.org.

We all know Heroku is a platform as a service (PaaS) that enables developers to build, run, and operate applications entirely in the cloud and most of it for free

So it's a good idea to maintain your Ghost powered blog for free on Heroku

To get started head over to my Github project ghostonheroku

Then simply click on 'Deploy to Heroku button'

Then you will be redirected to the Heroku website to create a New App

Here we are using JawsDB MySQL and Mailgun as addons don't worry both are free addons and then click deploy

It will take some time to configure the environment and build the app
After its deployed to Heroku, open the app

Congratulation 🎉 you have deployed your blog app to Heroku!

After deployment,

First, visit Ghost at https://YOURAPPNAME.herokuapp.com/ghost to set up your admin account
The app may take a few minutes to come to life
Your blog will be publicly accessible at https://YOURAPPNAME.herokuapp.com
If you subsequently set up a custom domain for your blog, you’ll need to update your Ghost blog’s PUBLIC_URL environment variable accordingly, heroku config:set PUBLIC_URL=https://www.example.com

For more in-depth tech details Check out the project Readme on Github https://github.com/manisaiprasad/ghostonheroku

Thank you! Happy Blogging 🎉

Comment down our views and if any issues

Developer analysis of programming languages used in the United States 2020

Mani Sai Prasad — Mon, 03 Aug 2020 21:54:15 +0000

Hello, fellow developers here are some analysis of programming languages used in the United States as per 2020 based on the Stackoverflow’s 2020 Annual Developer Survey.

Let's dig into the analysis

What are the most common programming languages in the United States?
Demanding programming languages in the United States?
What are the most popular roles in the United States?

What are the most used programming languages in the United States?

We can see that languages like JavaScript, HTML/CSS, SQL, and Python are still in the top positions.

We can see that in 2020 python has risen a lot compared to other languages in the survey

Demanding programming languages in the United States?

We can see that Python has grown tremendously rather then other languages. This is probably happening because it’s a programming language that is very versatile and has been used extensively in data-related areas.

Because now we are seeing more interest in machine learning and data science

What are the most popular roles in the United States?

We can see that Full Stack developer is the most popular role among the United States.

Back-end developer, Front end developer is the most popular occupation among participants after 2020.

The mobile developer is the popular role among participants in 2019, whereas in 2020 its trend is slowing down.

Conclusion

In this article, we took a look at what were the most popular programming languages, according to Stackoverflow’s 2019 and 2020 Developer Survey data.

We have seen that programming languages like as JavaScript, SQL, and Python still dominates the industry

And we can see that Python has grown tremendously rather then other languages. This is probably happening because it’s a programming language that is very versatile and has been used extensively in data-related areas.

Back-end developer, Full-stack web developer, Front end developer is the most popular role among participants after 2020.

To see more about this analysis, see the link to GitHub repo here

https://github.com/manisaiprasad/Dev-analysis-sof-2020

References

Stackoverflow Developer Survey Data: https://insights.stackoverflow.com/survey

Data in NumPy

Mani Sai Prasad — Wed, 20 May 2020 07:05:42 +0000

Python is excellent, but some times it can be slow. Happily, it allows us to access libraries that can execute faster code which is written in languages like C. NumPy is one such library: which provides fast alternatives to math operations in Python and is designed to work efficiently with groups of numbers - like tensors

Importing NumPy

When importing the NumPy library, the convention most often used is np

import numpy as np

Data Types and Shapes

The most common way to work with numbers in NumPy is through ndarray objects. Kind of Similar to Python lists, but can have any number of dimensions. Also, ndarray supports fast math operations, which we want.
Since it can store any number of dimensions, we can use ndarrays to represent any of the data types like

scalars
vectors
matrices
or tensors

Scalars

Scalar is simply a quantity described by a single element

In NumPy, we can specify signed and unsigned types, as well as different sizes. Instead of Python’s types like uint8, int8, uint16 and so on..

These types of objects we make (vectors, matrices, tensors) eventually store scalars. And when we create a NumPy array, we can specify the type - but every item in the array must have the same type.

NumPy arrays are more like C arrays than Python lists.
We can create a NumPy array that holds a scalar by passing the value to NumPy's array function

s = np.array(5)
s.shape

out: ()

() means it has zero dimensions.

x = s + 3
x

out: 8

Vectors

Vector is simply like an array with one dimension, consist of one or more scalars

We can create a vector, by passing a Python list to the array function

v = np.array([1,2,3])
v.shape

out: (3,)

(3,) means it has one dimension.

x = v[1]
x

out: 2

We simply index to get a value

Matrices

We create matrices using NumPy's array function, as just we did for vectors. However, instead of just passing a list, we need to supply a list of lists, where each list represents a row. So to create a 3x3 matrix containing the numbers one through nine

m = np.array([[1,2,3], [4,5,6], [7,8,9]])
m

array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])

m.shape

which return (3, 3), it represent two dimensions

Tensors

Tensors are just like vectors and matrices, but they can have more dimensions, like n dimensions
For example, to create a 3x3x2x1 tensor you could do the following:

t = np.array([[[[1],[2]],[[3],[4]],[[5],[6]]],[[[7],[8]],\
    [[9],[10]],[[11],[12]]],[[[13],[14]],[[15],[16]],[[17],[17]]]])
t

it's like

array([[[[ 1],
         [ 2]],

        [[ 3],
         [ 4]],

        [[ 5],
         [ 6]]],


       [[[ 7],
         [ 8]],

        [[ 9],
         [10]],

        [[11],
         [12]]],


       [[[13],
         [14]],

        [[15],
         [16]],

        [[17],
         [17]]]])

with a shape of (3, 3, 2, 1)

Changing Shapes

Sometimes we need to change the shape of the data without actually changing its contents. For example, you may have a vector, which is one-dimensional but need a matrix, which is two-dimensional. So, here we can reshape it

v = np.array([1,2,3,4])
v.shape

(4,)
its a vector
so here we can reshape by following:

x = v.reshape(1,4)
x.shape

(1, 4)
which is a matric we wanted

If you see code from experienced NumPy users, you will often see them use a special slicing syntax instead of calling reshape. Using this syntax, the previous examples would look like this:

x = v[None, :]
x

array([[1, 2, 3, 4]])

Element-wise operations

lets see how we can do with Python

Suppose we had a list of numbers, and you wanted to add 5 to every item in the list. Without NumPy, you might do something like this:

values = [1,2,3,4,5]
for i in range(len(values)):
    values[i] += 5
values

[6, 7, 8, 9, 10]

we can say its not that great

Lets see the NumPy way

values = [1,2,3,4,5]
values = np.array(values) + 5
values

array([ 6, 7, 8, 9, 10])

Creating that array may seem odd, but normally you'll be storing your data in ndarrays anyway. So if you already had an ndarray named values, you could have just done:

values += 5
values

array([11, 12, 13, 14, 15])

NumPy actually has functions for things like adding, multiplying, etc. But it also supports using the standard math operators. So the following two lines are equivalent:

x = np.multiply(values, 5)
x = values * 5
x

array([55, 60, 65, 70, 75])

Matrix Multiplication

NumPy Element-wise Matrix Multiplication

NumPy supports several types of matrix multiplication.
Element-wise Multiplication

m = np.array([[1,2,3],[4,5,6]])
n = m * 0.25
n

array([[0.25, 0.5 , 0.75],
       [1.  , 1.25, 1.5 ]])

np.multiply(m, n)

array([[0.25, 1.  , 2.25],
       [4.  , 6.25, 9.  ]])

Matrix Product

The number of columns in the left matrix must equal the number of rows in the right matrix.
The answer matrix always has the same number of rows as the left matrix and the same number of columns as the right matrix.
Order matters. Multiplying A•B is not the same as multiplying B•A.
Data in the left matrix should be arranged as rows., while data in the right matrix should be arranged as columns.

To find the matrix product, we use NumPy's matmul function.

If you have compatible shapes, then it's as simple as this:

a = np.array([[1,2,3,4],[5,6,7,8]])
a.shape

(2, 4)

b = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
b.shape

(4, 3)

c = np.matmul(a, b)
c

out:

array([[ 70,  80,  90],
       [158, 184, 210]])

If your matrices have incompatible shapes, you'll get an error, like the following:

np.matmul(b, a)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-67-af3b88aa2232> in <module>
----> 1 np.matmul(b, a)

ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 2 is different from 3)

NumPy's dot function

You may sometimes see NumPy's dot function in places where you would expect a matmul. It turns out that the results of dot and matmul are the same if the matrices are two dimensional.
So these two results are equivalent:

a = np.array([[1,2],[3,4]])
np.dot(a,a)

array([[ 7, 10],
       [15, 22]])

np.matmul(a,a)

array([[ 7, 10],
       [15, 22]])

While these functions return the same results for two-dimensional data, you should be careful about which you choose when working with other data shapes.

Play here

Link to an interactive colab notebook