Current metaverse ambitions are centered on addressing technological limitations with modern virtual and augmented reality devices, as well as expanding the use of metaverse spaces to business, education, and retail applications.Numerous entertainment and social media companies have invested in metaverse-related research and development.

The metaverse has come to be criticised as a method of public relations building using a purely speculative, "over-hyped" concept based on existing technology. Information privacy and user addiction are concerns within the metaverse, stemming from current challenges facing the social media and video game industries as a whole

Elements

The metaverse is described as a means of manufacturing immersive digital spaces for a range of human activity. To achieve this, some iterations of the metaverse involve integration between virtual and physical spaces and virtual economies. Additional qualities include digital persistence and synchronicity in order to better establish a sense of presence in a realistic environment, along with implementing existing social media elements such as avatar identity, content creation, and social acceptability

Current Implementations

Video games

Several components of metaverse technologies have already been developed within modern internet-enabled video games. The 2003 video game Second Life is often described as the first metaverse, as it incorporated many aspects of social media into a persistent virtual world. Social functions are often an integral feature in many massively multiplayer online games. Technology journalist Clive Thompson has argued that the emergent, social-based gameplay of Minecraft represents an advanced implementation of the metaverse. Similar statements were made for the game Roblox, which has since employed significant usage of the term in marketing. Other claims of developing a metaverse include the games Active Worlds, Decentraland, and Fortnite in addition to a few early MUD games.

Virtual reality

Metaverse development has often focused on bettering virtual reality technologies due to benefits in establishing immersion in virtual environments. In 2019, the social network company Facebook launched a social VR world called Facebook Horizon. Facebook would later be renamed "Meta Platforms" in 2021. Its chairman Mark Zuckerberg declared a company commitment to developing a metaverse ecosystem. Much of the underlying virtual reality technology that Meta Platforms advertised remains to be developed. Microsoft acquired the VR company AltspaceVR in 2017, and is planning on integrating metaverse features into Microsoft Teams.

Potential Implementations

Some developers have proposed using metaverse technology for improvements in work productivity.

Within the education sector, metaverse technologies have been proposed as a way to allow for interactive environments for learning. The metaverse could also host virtual reality home tours in the real estate sector.

Technology

The metaverse is a proposed expansion to existing internet technologies. Access points for the metaverse include general-purpose computers and smartphones, in addition to augmented reality (AR), mixed reality, virtual reality (VR), and virtual world technologies.

Business and commercial interest in metaverse-related research and technology include Facebook, which bought VR company Oculus in 2014, and has announced plans to build a 3-D social space to connect varying services.

The metaverse's dependency on VR technology places limitations on its development and wide-scale adoption. Limitations stemming from the balance between cost and design include the lack of high quality graphics and a lack of mobility. Lightweight wireless headsets lack image quality, which is optimized for bulky, wired VR goggle systems. Another issue for wide-scale adoption of the technology is the cost, with the HTC Vive Pro 2 headset costing US$799 plus controllers in 2021.

In 2021, the South Korean government announced the creation of a national metaverse alliance with the goal to build a unified national VR and AR platform.

Technical Standards

Common standards, interfaces, and communication protocols among virtual environments are in development. Collaborations and working groups are attempting to create standards and protocols to support interoperability between virtual environments, including:

OpenXR, application programming interfaces (APIs) for interfacing with VR and AR devices, Khronos Group (2019–present) Virtual Worlds—Standard for Systems Virtual Components Working Group (P1828), IEEE (2010–Present) Information technology—Media context and control—Part 4: Virtual world object characteristics (ISO/IEC 23005-4:2011), ISO (2008–Present) Immersive Education Technology Group (IETG), Media Grid (2008–Present) Virtual World Region Agent Protocol (VWRAP), IETF (2009–2011) The Metaverse Roadmap, Acceleration Studies Foundation (2006–2007) The Open Source Metaverse Project (2004–2008) X3D, the successor to the Virtual Reality Modeling Language (VRML) as the open standard for interactive real-time 3D (web3D). X3D is an accepted standard for integrating virtual and augmented realities with the web

Criticism and Concerns

The term arose in the early 1990s, and has come to be criticised as a method of public relations building using a purely speculative, "over-hyped" concept based on existing technology.

Information privacy in the metaverse is an area of concern because the companies involved will likely collect users' personal information through wearable devices and user interactions. Facebook is planning on persisting targeted advertising within the metaverse, raising further worries related to the spread of misinformation and loss of personal privacy. AR pioneer Louis Rosenberg warned that the metaverse could be more polarizing than social media, driving people from their information bubbles to their "own custom realities” and that users could selectively “reality block” the parts of society they don’t like.

User addiction and problematic social media use is another concern for the development of the metaverse. Internet addiction disorder, social media, and video game addiction can have mental and physical repercussions over a prolonged period of time, such as depression, anxiety, and obesity. Experts are also concerned that the metaverse could be used as an 'escape' from reality in a similar fashion to existing internet technologies.

The metaverse may magnify the social impacts of online echo chambers and digitally alienating spaces. Since metaverse developments may be made to algorithmically tailor virtual worlds based on each person's beliefs, the metaverse may further distort users' perceptions of reality with biased content to maintain or increase engagement.

Fiction

Snow Crash

The term metaverse was coined in Neal Stephenson's 1992 science fiction novel Snow Crash, where humans, as avatars, interact with each other and software agents, in a three-dimensional virtual space that uses the metaphor of the real world. Stephenson used the term to describe a virtual reality-based successor to the internet.

Neal Stephenson's metaverse appears to its users as an urban environment developed along a 100-meter-wide road, called the Street, which spans the entire 65536 km (216 km) circumference of a featureless, black, perfectly spherical planet. The virtual real estate is owned by the Global Multimedia Protocol Group, a fictional part of the real Association for Computing Machinery, and is available to be bought and buildings developed thereupon.

Users of the metaverse access it through personal terminals that project a high-quality virtual reality display onto goggles worn by the user, or from grainy black and white public terminals in booths. The users experience it from a first-person perspective. Stephenson describes a sub-culture of people choosing to remain continuously connected to the metaverse; they are given the sobriquet "gargoyles" due to their grotesque appearance.

Within the metaverse, individual users appear as avatars of any form, with the sole restriction of height, "to prevent people from walking around a mile high". Transport within the metaverse is limited to analogs of reality by foot or vehicle, such as the monorail that runs the entire length of the Street, stopping at 256 Express Ports, located evenly at 256 km intervals, and Local Ports, one kilometer apart.

Ready Player One

Ready Player One is a 2011 dystopian science fiction novel by Ernest Cline, depicting the world in the year 2045 as being gripped by an energy crisis and global warming, causing widespread social problems and economic stagnation. The primary escape for people is a metaverse called the OASIS, which is accessed with a VR headset and wired gloves. It functions both as an MMORPG and as a virtual society. A film adaptation was released in 2018

One consequence of simplifying the UI was hiding the good old HTML editor and for a good reason - 99,9% of users don’t need it at all. But without it, adding banners, images, tables or other visual media and making them all look good together on any screen size is really tough (if not impossible). Luckily, with a simple workaround, you can still use HTML templates in your Gmail messages.

Copy/Pasting HTML Into Gmail

Now let’s see what happens if we just insert HTML code into a Gmail Compose window. We’re not really sharing this email with our entire mailing list so it can be simple stupid. Let’s try with this one:

<p>Simple HTML.</p>
<h3><em>So very simple.</em></h3>
<p><span style="color: #ff0000;">Lame joke that follows.</span></p>
<p>
  <span style="color: #ff0000;"
    ><img
      src="https://afinde-production.s3.amazonaws.com/uploads/981ebabb-5722-44c1-ad30-fc57fbc8ee9d.jpeg"
      alt="Lame joke"
      width="245"
      height="221"
  /></span>
</p>
<h2 style="padding-left: 30px;">do you?</h2>
<ul>
  <li>yes</li>
  <li>no</li>
  <li><strong>not entirely sure</strong></li>
</ul>

And let’s paste it directly into Gmail and send:

Yup, that doesn’t look quite right. Gmail uses a WYSIWYG editor so whatever you paste into the Compose window, will look just about the same on the receiver’s end. That’s why we’ll need to take a different approach.

Inserting HTML Into Gmail

First of all, compose or export HTML code and save it as a .html file. Make sure your editor saves files as plaintext, without any additional formatting. It also cannot add .txt or any other extensions to the file name, otherwise, the code won’t be rendered properly. Mac’s TextEdit, for example, needs a few tweaks to work with HTML as expected.

Now, try to save it. Notice how it adds .txt extension by default, making the file useless. Be sure to use File -> Save on Mac and uncheck the part about .txt extension.

Right-click on the file and open it with a browser of your choice. It should render as expected. If you see raw HTML, double-check if the file was saved properly and if your editor relies on plain text.

Copy the entire content of a page, either with Ctrl+A (Windows) / Cmd+A (Mac) or just use a mouse or a trackpad. Then, insert it into your Gmail’s compose window and send it!

What To Pay Attention To When Writing An HTML Email?

Although HTML is a really simple framework, there are several features/limitations of Gmail that you need to be aware of. Here are the main ones:

1. Images Need To Be Hosted Online And Available Publicly If you were to add images to an email, they would be stored as attachments. This is probably not the ideal way for a recipient to access the pictures. That’s why images need to be uploaded somewhere on the internet and referenced with a link in the HTML code.

If possible, store them on your own server or use, for example, Google Drive. When uploading to the latter one, make sure the link is public, not private (trying to access it in the incognito mode should do the job). When uploading to popular image sharing services such as Imgur or Tinypic, make sure you fetch a direct link to an image, not to a folder where it’s stored.

1. External Style Sheets Won’t Work Gmail doesn’t offer support for external styles. You can, however, utilize embedded CSS as well as Inline styles. A good responsive email typically consists of a fair share of Inline CSS, used mainly to maintain a proper structure and styling of a message. Embedded CSS is used to add CSS Reset Styles and rules required to make an email responsive.

2. You Can’t Use Web Fonts Gmail doesn’t let you utilize any of the web fonts and there’s no way to import them into your HTML. You’ll need to use one of the available fonts in your emails:

Utilizing HTML Editors

But do you really need to write an entire HTML code from scratch or test how it looks on different screens? Likely, you don’t. There’s an abundance of free and paid email editors available both online and for download.

Some free editors worth a look are Htmlg.com or W3schood editor. They offer a bit more than the default Google editor. But the biggest value is from the chance to preview your emails as you write or change it.

More sophisticated tools come with lots of templates ready for any occasion. So whether you’re after infographic templates or wish to invite someone to a wedding, you’ll have plenty to choose from.

Pick the right one, adjust it to your needs, preview and download the entire HTML code. Then just follow the instructions above to send it with Gmail or use any other client or email service provider (ESP). Most of these tools run on a freemium model, letting you try some basic templates for free and charging you for more advanced ones.

Final Words

As you can see, sending HTML emails via Gmail isn’t difficult at all. The tricky part might be to display them properly in the vast array of browsers and email clients. With a bit of practice and the appropriate toolset, it shouldn’t cause a problem too.

Now, pick the right email design, launch Gmail or an email marketing provider of your choice and send your next campaign without any hassle.

musprodev@outlook.com

Learning python is easy as compared to other high-level, object-oriented programming languages such as Java or C++but it has a few advanced concepts that come in handy when developing code that is robust, crisp, highly optimized, efficient, and normalized. Using these concepts in your code, you will be able to reduce bugs in your code as well as increase its efficiency thereby making you a seasoned Python programmer. So let us look at these concepts one by one and understand them in detail!

1 . MAP FUNCTION

Python has an inbuilt function called map() which permits us to process all the elements present in an iterable without explicitly using a looping construct. When used, it returns a map object which in turn is an iterator. This map object is the result obtained by applying the specified function to every item present in the iterable.

The map() function takes two arguments:

• The first argument is a function that is to be applied to each and every element present in the iterable.

• The second argument is the iterable itself on which the function is to be mapped.

2 . Itertools

Python has an amazing standard library called itertools which provides a number of functions that help in writing clean, fast, and memory-efficient code due to lazy evaluation. It is a Python module that implements various iterator building blocks and together they form ‘iterator algebra’ which makes it possible to efficiently build tools in the Python language. The functions in itertools work on iterators itself which in turn return more complex iterators. Some example of functions present in itertools are: count(), cycle(), repeat(), accumulate(), product(), permutations(), combinations() etc. each taking their own set of arguments and operating upon them. The result is generated a lot more faster as compared to the results achieved when using conventional code.

3. Lambda Function

Python’s lambda functions are small anonymous functions as they do not have a name and are contained in a single line of code. The keyword ‘def’ is used to define functions in Python but lambda functions are rather defined by the keyword ‘lambda’. They can take any number of arguments, but the number of expressions can only be one. It makes code concise and easy to read for simple logical operations and is best to use when you need to use the function only a single time.

4. Exception Handling

Exceptions are types of errors that occur when the program is being executed and change the normal flow of the program. An example could be dividing a number by zero or referencing an index that is outside the bounds of an iterable. Therefore, we use try, except, and finally to handle exceptions in Python. The keyword try is used to wrap a block of code which can potentially throw errors, except is used to wrap a block of code to be executed when an exception is raised and handles the error and finally lets us execute the code no matter what.

5. Decorators

Decorators are a part of Python’s metaprogramming which are used to add additional functionality to existing code without altering the original structure at compile time. It is more like a regular function in Python which can be called and returns a callable. It takes in a function, modifies it by adding functionality, and then returns it.

6. Collections

Collections in Python are general purpose inbuilt containers like set, tuple, dictionary, and lists. Python collections is a module that implements specialized container datatypes. Collections include namedtuple() which is a function for creating tuple subclasses with named fields, OrderedDict which is a dict subclass that remembers the order entries that were added since Python dict aren’t ordered, Counter that is used for counting hashable objects, ChainMap that is used for creating a single view of multiple mappings, etc.

7. Generators

Generators in Python are a special type of function that rather than returning a single value, returns an iterator object which is a sequence of values. It is a utility to create your own iterator function. The keyword yield is used in the generator function instead of the return keyword which pauses its execution. The difference between yield and return is that return terminates the function but yield only pauses the execution of the function and returns the value against it each time.

8. Magic Methods

Also called Dunder (or double underscore) methods, magic methods are special types of functions that are invoked internally. They start and end with double underscores. Some examples include add(), abs(), round(), floor(), str(), trunc(), lshift() etc. The expression number + 5 is the same as numer.add(5) and this is internally called by other methods or actions. You can directly use these functions as it will decrease the run time of your code due to the fact that now due to direct use, we will be reducing a function call each time.

9. Threading

A Thread is the smallest unit or process that can be scheduled by an operating system. Python contains the Thread class which aids in multithreaded programming. Multithreading is mainly used to speed up computation up to a huge extent as now more than one thread will be performing tasks. To implement threading in Python, you will need to use the threading module (since the thread module is deprecated).

10. Regular Expressions

Python regular expressions or RegEx are expressions that contain specific characters as patterns to be matched. It is used to check if a string or a set of strings contains a specific pattern. It is extremely powerful, elegant, and concise along with being fast. To use Python’s regular expressions, you need to import re module which contains functions that help in pattern matching like findall(), search(), split(), etc.

These were the top advanced Python concepts that you must know to be an experienced Python developer. These will not only make you a good programmer and developer but will also improve code readability and make it faster.

TELEGRAM

However, starting a blog could bring many advantages. When you write on the Internet you become more visible than a regular developer. Who are you hoping will read your post? Future colleagues? A recruiter from that awesome company you’d like to work at? The committee responsible for choosing the speakers of a conference you’d like to talk at? All these people will be interested in both your technical skills and your editorial skills.

Also, what better way is there to learn than by explaining to other people? That’s exactly what you’ll be doing when you write a technical post on your blog.

So now we’ve convinced you that starting a blog is what you want to do, how should you go about it?

HASHNODE is an awesome platform, where a lot of people write amazing stuff. You’ll have nothing to configure, meaning you can start straight away.

Hashnode is the easiest way to start a developer blog on your personal domain 🌏 for free and connect with the readers through our global dev community! 👩‍💻👨‍💻

A blogging platform built for developers by developers. Blog on personal domain, share ideas, and connect with the global dev community!

How to use Hashnode

• Go to www.hashnode.com

• Click on get started

• Sign up using your email,:( I prefer signing in-out with google

• Fill in the necessary information and click next

• Follow your favourite technologies

• Click on get started

• Enter your personal blog name

• Click on "Write an Article"

• Write your GREAT content

• Click on Publish and your blog is live.

Share your content

Social media is key to making your blog a well-read platform. The more platforms the merrier? Not necessarily. Choose wisely: Some are irrelevant because developers don’t go there to read tech stuff. So don’t waste time juggling 36 social-media accounts. More than anything else, you’ll need this time to write great posts and work on your awesome side projects!

Sharing is caring, so share your posts often. No one likes to talk to themselves. To avoid disappointment with the reaction to your blog at the start, which may lead you to think about closing it after 2 weeks, share your posts with your family, friends, and acquaintances. There’s no easier way to do that than with social media.

The key social-media platforms have their own uses. On Twitter, for example, since the posts scroll rapidly out of sight, you can share the same links to your blog multiple times a day. It is always possible that one of your followers spends their whole day on Twitter and will see the same link several times, so try to use different descriptions with them. You can also retweet people who have retweeted and commented on your posts, which will make them appear in your feed. This is a way to maintain a steady flow of readers. Keep in mind that even if the post already appeared on social media 2 months previously, not all your followers who might be interested in it will have seen it, so repost it.

Use your network

We developers have a big asset that we can use to our benefit: Programming is a niche market with highly engaged members. Websites such as Hacker News, Dev.to, Medium, and tech subreddits are places packed with developers hungry for great technical posts to read, so feed them yours and use those websites to get known.

On Hacker News and subreddits, you can send your links with a description. On Medium and Dev.to you have to write a post: Just copy and paste your blog posts (with canonical links to your original post) to create interest and draw developers from these platforms to your own blog. You can also make guest posts on Medium or Dev.to publications that already have lots of readers, such as HackerNoon. You’ll find a lot more places like this on the Internet. Using them is important.

Engage with your community

At this point, you already share your posts everywhere, but it’s not enough! Ask questions, answer comments, talk about your work, your daily life, make videos if you feel comfortable doing so. Your readers are developers, so they are human beings too. People need to be able to relate to you to build a sense of community. An engaged reader will help greatly by sharing your posts on social media, commenting, giving you feedback… Value those readers by taking the time to thank them! If you get some negative feedback or the content is not interesting enough for your readers, just try something else.

THANKS FOR READING

CONTACT ME-FOLLOW ME

● TELEGRAM

● WHATSAPP

● INSTAGRAM

● TWITTER

What are --css variables

CSS variables are a way for you to assign certain css values to a keyword and reuse them throughout your application. CSS variables can have local or global scope and can be manipulated with JavaScript. Most often, they are used to help you manage your colors but you can use css variables many different ways. In the simplest form, a css variable is nothing but a keyword that has a value assigned to it.

Syntax To declare and use a css variable is very simple. There are 3 main things you need to remember: -- ``:root var().—- is used whenever you assign and declare your variable. To create a variable you must put —- in front of your variable name.

:root{
/* my variable name is main-color and my value associated with 
it is #5a9e4b */
--main-color: #5a9e4b;
}

:root is how you declare global scope. Scope is basically where all you can access your variable from. Global scope means you have access throughout your css file. You can create a local variable by using the —-variable-name inside of a class. A local variable means that you only have access to this variable locally inside that class.

/* This is declaring a global variable that I can access from anywhere in my css file. Anything inside of :root is global.*/
:root{
—-main-color: #5a9e4b;
}

/* This is declaring a local variable. I can only access this variable inside of this class */
.container {
--main-text-size: 24px;
font-size: var(--main-text-size);
}

var() is how you call your variables. Remember a variable is nothing but a keyword that has a set value. To pass this value to a css property all you have to do is type the name of your variable inside of the (). It’s that simple!

/* creating a global variable for main-color */
:root{
—-main-color: #5a9e4b;
}

/* passing the variable name into the var function. This will put #5a9e4b as the value to the color property. */
.someClass {
color: var(—-main-color);
}

Fallbacks

Unfortunately not all browsers are created equally. While most browsers are pretty robust its best practice to have some fallbacks in place. There is special syntax that you can use to have a fallback for your value. Its the same var() as before but you add a second argument. var(--main-color, blue); This will use your css variable --main-color and if it is invalid or not defined it will then make the value equal to blue. The var() only takes in two arguments and the second argument can be an additional css variable if you want. var(--main-color, var(--ultimate-fallback)); This will try to use main-color first and if its invalid will then use the --ultimate-fallback.

:root {
--main-color: #5a9e4b;
}

p {
/* will try --main-color first. If invalid will use blue */
color: var(--main-color, blue);

Now this will not act as a fall back for browsers that do not support css variables. To create a fallback for this is a little extra work but possible. CSS reads one line at at time. You can have the same property with two different values for the same class and css will use the last one written. We can take advantage of this with our variables. You can hard code your fallback in your css class and then on the next line add your css variable. Css will read each line and if the browser does not support css variables it will then default to your hard coded fallback. If the browser does support css variables then it will use it since it was used after the fallback.

:root {
--main-color: #5a9e4b;
}

p {
/* will use --main-color since it is last color property written. If invalid will then use blue.*/
color: blue;
color: var(--main-color);

Using JavaScript

Since css varaibles have access to the DOM you can change them with JavaScript! You can make some really interesting user interfaces with this trick. To start create your css variables like you normally would. Then use querySelector to get access to the root element. Now that you have access to the root element, all you have to do is use the setProperty() method to change the value of you variable. This will update the value and hence update your entire css file everywhere you used that variable. The setProperty() method is a method on CSSStyleDeclaration Object. I won’t go into detail on this or the other methods you can use. I want to keep this article light and focused on css varaibles instead of JavaScript. Go to https://www.w3schools.com/jsref/obj_cssstyledeclaration.asp If you would like to learn more about what you can do.

:root {
—-primary-color: #5a9e4b;
}

p {
color: var(—-primary-color);
}

//gives me access to the root element
let rootElement = document.querySelector(':root');

//this will change the style of my 
—-primary-color variable to red.
rootElement.style.setProperty('- 
-primary-color', 'red');

In the above example I have a css variable called —-primary-color that is set to the value of #5a9e4b. Then I make the color to all of my

tags equal to my new variable. In the JavaScript section, I first create a variable that is equal to the root element. Then I can access my variable by using the setProperty('variable name', 'new value') method. The first argument is the variable name and the second argument is the new value. Now all my

will have red text!

You now have the knowledge needed to start using css varaibles in your applications. This will help increase developement speed, readability, and maintainability. If you enjoy this you can look into things like Sass to further extend your css capabilities.

https://t.me/musprodev

Anyone who has worked on a decent-sized React-Redux project knows how many times you have to write the same code to connect the Redux Store Data to the Component Props.

Today we are going to fix that and provide you with a way to streamline ANY Repetitive Code you have and Maximize your Productivity.

What are Snippets in VS Code?

VS Code is an Amazing Code Editor that provides a plethora of tools to take your productivity to the next level. Snippets are just one such tool.

Snippets can be thought of as Templates that enable you write code once and reuse it, as per requirement. It allows Variables as well as Dynamic User Inputs.

If you have been using VS Code for some time, you are bound to come across Snippets.

Some Snippets come pre-built with VS Code. You can install some extensions to add event more Snippets, but most importantly, you can create your own Snippets to cater to your very own needs.

Creating our first Snippets

Creating a Snippets is fairly simple:

1- Go to File > Preferences > User Snippets (possibly Code > Preferences > User Snippets on macOS).

Or you might use F1 to bring up the Command Palette and search for User Snippets

2- Select the type of Snippet you want to create (language-specific, project-specific or global)

3- Add the following in the created .code-snippets file

    {

    "Signature": {
    "scope": "html",
    "prefix": "hello",
    "body": [
        "Hello!!!"
    ],
    "description": "Hello"
    }
   }

4- Done! Now when you type "hello" in an HTML file, you would be to use the Snippet

This wasn't a practical example, but we did manage to get our feet wet at making Snippets.

On inspecting the Snippet definition, we find the scope that declares which files the Snippet should be used in. The prefix mentions the prefix text that will trigger the Snippet to show up. The body defines the body of the Snippet(each line of the Snippet would be a new string in array). And finally, description is a short description of the Snippet's function.

Let us make a couple of practical ones to deepen our understanding and solve the issue mentioned in the Intro of the article (connecting State/Dispatch to Props using React-Redux).

Snippet 1: Leaving a Signature

Let's try making a snippet that leaves a signature like this in any file and isn't restricted to only Python

"""
Name: Tapajyoti Bose
Modified on: 05 September 2021 
08:38:35
"""

We would also like the Snippet to update the date and time dynamically, of course.

Luckily, VS Code provides a bunch of variables for this purpose.

We would be using BLOCK_COMMENT_START and BLOCK_COMMENT_END to automatically generate the block comments for any language and CURRENT_DATE, CURRENT_MONTH_NAME, CURRENT_YEAR, CURRENT_HOUR, CURRENT_MINUTE, & CURRENT_SECOND to generate the date and time dynamically.

NOTE: To get the complete list of variables, click here

So the Snippet would initially look like this:

"Signature": {
"scope": "python,javascript,typescript,html,css",
"prefix": "signature",
"body": [
    "$BLOCK_COMMENT_START",
    "Name: Tapajyoti Bose",
    "Modified on: $CURRENT_DATE $CURRENT_MONTH_NAME $CURRENT_YEAR $CURRENT_HOUR:$CURRENT_MINUTE:$CURRENT_SECOND",
    "$BLOCK_COMMENT_END"
],
"description": "Leave a signature"
}

Now within Python, Javascript, Typescript, HTML, CSS files, you would be able to leave a signature.

You might be wondering if extending the functionality to all languages would require you to add the names of all languages. Luckily there is an easy solution: just remove the scope from the Snippet definition and Viola! the functionality is extended to all languages!

Snippet 2: Connecting Redux to React Props

This is even easier than the Signature Snippet. Just copy the following code in the snippet definition, and you are done:

"Connect Component to Redux": {
"scope": "javascriptreact,typescriptreact",
"prefix": "connect",
"body": [
    "const mapStateToProps = (state) => ({",
    "\t$1",
    "})",
    "",
    "const mapDispatchToProps = (dispatch) => ({",
    "\t$0",
    "})",
    "",
    "export default connect(mapStateToProps, mapDispatchToProps)($TM_FILENAME_BASE)"
],
"description": "Connect React Component to Redux"
}

Let us examine what is being done.

We are scoping the Snippet to React based projects for obvious reasons.

In the body, you might be seeing $0 and $1 for the first time. These are placeholders for tab-able positions where the user should enter their own logic (the parts of the store they want to connect to the props in this case).

We are using the File Name as the Component Name, as in most cases, the convention is using the Component Name to be the same as the File Name.

THANKS FOR READING

Follow my blog and subscribe to my newsletter for future updates

CONTACT ME

● Instagram

● Twitter

● Telegram

Configuring the Flask backend.

1. routes.py

Before we continue. Let's alter our Flask routes.py to accept input from the React frontend, then commit the database. We'll add the following lines of code to our routes.py file.

@app.route("/add", methods=["POST"], strict_slashes=False)
def add_articles():
title = request.json['title']
body = request.json['body']

article = Articles(
    title=title,
    body=body
    )

db.session.add(article)
db.session.commit()

return article_schema.jsonify(article)

The function above basically gets an article title and description in json format, adds the record to the database, and then commits, i.e. saves.

Part 2

Configuring the React frontend.

In contrast to the last tutorial, we will make some changes to our project by introducing a Components directory. Then we'll add some new files, one to manage our API services and another to display a form to the UI, as well as to handle our interaction with the APIService, which provides our data to Flask.

2. Components/APIService.js

export default class APIService{
// Insert an article
static InsertArticle(body){
    return fetch(`http://localhost:5000/add`,{
        'method':'POST',
         headers : {
        'Content-Type':'application/json'
  },
  body:JSON.stringify(body)
})
.then(response => response.json())
.catch(error => console.log(error))
}

}

To better organize our files and increase efficiency, we conduct all of the Flask API services in a single file and then call the methods as needed.

The code above requests our Flask routes, which handle data insertion, and then posts our JSON-stringified article title and description. Flask takes care of the rest under the hood.

3. Components/Form.js

import { useState } from 'react';
import APIService from '../Components/APIService'

Because we'll require the React useState hook and the APIService component, we make them available as seen above.

const Form = (props) => {
const [title, setTitle] = useState('')
const [body, setBody] = useState('')

const insertArticle = () =>{
  APIService.InsertArticle({title,body})
  .then((response) => props.insertedArticle(response))
  .catch(error => console.log('error',error))
}

const handleSubmit=(event)=>{ 
  event.preventDefault()
  insertArticle()
  setTitle('')
  setBody('')
}

  return (
   <div>
   // Form
   </div>
  )}

export default Form;

3. App.js

As we near completion, we need to show the Form component on the UI. We'll import it then display it on the UI as shown in the steps below.

// import the component
import Form from './Components/Form'

Previously, we passed the response from our APIService. InsertArticle() as a parameter, it's then received on this end. Using the spread operator we will combine the newly created article with the available articles. The update is initiated using the setArticles method and the result is a list of updated articles.

// update the existing article list
  const insertedArticle = (article) =>{
const new_articles = [...articles,article]
setArticles(new_articles)
  }

We now have our form ready to display on the UI. We can make it visible by calling the Form Component while passing to it the the data as props like this.

 <Form insertedArticle={insertedArticle

Also, keeping the form visible all the time isn't ideal, so we made it a toggle button.

// define variables for the present state of the form and another to change its state const [showForm, setShowForm] = useState(false); ... // toggle between the two states,visible and hidden const toggleShowForm = () => { setShowForm(!showForm); } ... // Trigger the hide/show method <button onClick={toggleShowForm} className="btn btn-primary"

Write an article ... // display the form conditionally {showForm && (

)}

Project preview

Thank you for reading. Please like, share, and leave a comment below.

Also do follow my blog to get notified when the next article on editing and deleting the articles we just published is posted.

Notifications can be shown even if the user is not active on your website/webapp.

Whether you are building an e-commerce website and want to show offers to your user or you are building a chatting application and want to show the notification about new messages.

Many top web applications like Slack, Facebook, WhatsApp and a lot more are using the same technology to show notifications.

Using Notifications API is lot more simpler than you might think.

Introduction.

The Notifications API allow developers to show notifications from their website or web application.

Notifications API is compatible with existing notifications system in your OS (Windows, Mac or Linux).

How to use Notifications API 💭

Notifications can be initialised using the class Notification which is available globally.

Asking for permission ⬇️

// asking user to grant the permission on page load
// to show notifications
window.addEventListener('load', () => {
  Notification.requestPermission();
// permission cannot be asked again if the user chose
// to grant or deny the permission.
// once granted or denied, then user have to change the
// permission manually.
});

Checking if the user has granted the permission ⬇️

console.log(Notification.permission);

Result of the above console can be:

default: Permission is not asked yet, notifications will not be shown.

granted: User has granted the permission to show notifications.

denied: User has declined the permission.

Alternatively, you can also use Permission API to check for the permission. More about it here.

Showing notifications 🔔

const newMsgNotification = new Notification('A new message', {
  body: 'You have got a new message, check it out!',
  icon: 'https://images.unsplash.com/photo-1611605698335-8b1569810432?ixid=MnwxMjA3fDB8MHxzZWFyY2h8N3x8aWNvbnN8ZW58MHx8MHx8&ixlib=rb-1.2.1&auto=format&fit=crop&w=500&q=60',
});

Above code shows the notification in my ubuntu something like this 👇

And that is it, this is as much that you need to know to get started, continue to know more.

In the above example you see Notification class accepts 2 arguments.

1. Title of the notification.
2. Options object in which you can set settings for notifications.

Interacting with the notifications: Users can also interact with the notification (like click on the notification).

EventListener can be added to notification instance.

// navigate the user to you website when
// user click on a notification


newMsgNotification.addEventListener('click', (e) => {
  e.preventDefault();

window.open('http://yourwebappurl.com', '_blank');
});

In addition to click listener, notification can listen to 3 more events:

close: Fired when the notification is closed.

error: Fired when the notification could not be shown for some reason.

show: Fired when the notification in displayed.

That is it for this article guys, I hope you found it useful.

If you did please subscribe to my newsletter, leave a like and share the article.

Choosing a text editor can be so frustrating sometimes, you should choose a text editor according to you needs and the way the software makes a your coding easy.

Here I recommend 2 Editors

• VISUAL STUDIO CODE

• SUBLIME TEXT

2. HTML

The HyperText Markup Language, or HTML is the standard markup language for documents designed to be displayed in a web browser. It can be assisted by technologies such as Cascading Style Sheets and scripting languages such as JavaScript.

3. CSS

Cascading Style Sheets (CSS) is a style sheet language used for describing the presentation of a document written in a markup language such as HTML.

4. BOOTSTRAP

Bootstrap is a free and open-source CSS framework directed at responsive, mobile-first front-end web development. It contains CSS- and JavaScript-based design templates for typography, forms, buttons, navigation, and other interface component

5. JAVASCRIPT

JavaScript is the world's most popular programming language. JavaScript is the programming language of the Web. JavaScript is easy to learn.

6. BUILD PROJECTS

The best way to learn web development is to find a project that will push you forward. Tony Mastrorio has a great article about getting out of “tutorial purgatory.” Everything he says in it is spot-on.

7. COMMAND-LINE

The command line is a text interface for your computer. It's a program that takes in commands, which it passes on to the computer's operating system to run. From the command line, you can navigate through files and folders on your computer, just as you would with Windows Explorer on Windows or Finder on Mac OS.

8. GIT AND GITHUB

what's the difference? Simply put,

Git is a version control system that lets you manage and keep track of your source code history. GitHub is a cloud-based hosting service that lets you manage Git repositories. If you have open-source projects that use Git, then GitHub is designed to help you better manage them.

9. JAVASCRIPT FRAMEWORKS

JavaScript frameworks, instead, are collections of different JavaScript code libraries that are compiled together to make it easy for a developer to refer to and use the scripts. In simple words, frameworks (FM, F/M, FRWK, FWK) are pre-built groups of codes that are put together to make development easy and hassle-free.

Do share if you find this article to be Helpful. And dont forget to subscribe to my news LETTER for future updates.

1. FIXING AN ELEMENT'S POSITION

/* suppose you want to fix your sidebar's position and size. .sidebar {

position: absolute;

top: 15px;

right: 15px;

width: 300px;

height: 150px;

}

** use this method carefully and test it beforehand on every screen size and resolution so that it doesn't break your site's design.

2. VISITED LINK STYLING

Use CSS code to tweak how the links look before and after visitors have clicked on them.

a:link {

color: #ff0000; the unvisited link is red */

}

a:visited {

color: #ee82ee; the visited link turns violet */

}

3. POSITION CONTENT IN THE CENTER

Placing content in the middle of the screen might be tricky. However, you can use position: absolute to override the dynamic placement and always position the content in the center.

section {

position: absolute;

left: 50%;

top: 50%;

transform: translate(-50%, -50%); padding: 30px;

}

4. HOVERING EFFECT DELAYS

The :hover selector is a CSS pseudo-class which allows you to create a hovering effect. However, you can further stylise this by adding a transition element to delay the hovering effect.

.entry h2{

font-size: 48px; color: #000000; font-weight: 750;

}

/* Next, add a delay to the hover effect */

.entry h2:hover{

color: #f00;

transition: all 0.5s ease;

}

5. INITIAL LETTER STYLIZING

Drop caps option is also written into the CSS language, so you can effortlessly use it and give your paragraphs a new look.

p:first-letter { 

display: block; 

float: left;

margin: 5px; 

color: #000000; 

font-size: 60px;

}

You can SUBSCRIBE to the my NEWSLETTER to receive updates in your mail

💬“In some ways, programming is like painting. You start with a blank canvas and certain basic raw materials. You use a combination of science, art, and craft to determine what to do with them.” (Andrew Hunt)

Why JavaScript?

💬“In some ways, programming is like painting. You start with a blank canvas and certain basic raw materials. You use a combination of science, art, and craft to determine what to do with them.” (Andrew Hunt)

Why JavaScript?

JavaScript, as you might know, is ubiquitous in today’s software development world. It is the foundation of frontend web development and is the key ingredient in frameworks like ReactJS, Angular, and VueJS. It can also help create solid backends with platforms like Nodejs, runs desktop applications like Slack, Atom, and Spotify, and runs on mobile phones as Progressive Web Apps (PWAs).

In short, it is everywhere—and for good reasons. For starters, compared to other languages like C and Java, JavaScript is generally easier to learn. When we say ‘easier’, we mean in terms of how quickly you can go from being a JavaScript novice to someone who can actually make a living writing professional, high quality JavaScript code. So, in that sense, it’s more accessible than some other languages like C and Java.

JavaScript is also a fun and rewarding language, which is especially important when you’re just getting started in software development. The community support is very good, so if you get stuck, there’s a good chance that the problem and its solution already exist on the web.

INTRODUCTION

Now that we’ve gotten a bird’s-eye view of JavaScript, let’s get into the more technical detail. JavaScript was created to add ‘life to webpages’. Just like HTML and CSS, JavaScript is written in plain text files with a .js extension.

As previously mentioned, JavaScript can be used to accomplish many useful operations on the frontend, like validating forms, alerting users, storing temporary data, and performing calculations—to name just a few.

😎Pro tip: Apart from the name itself, JavaScript has no relation to Java. Beginners often get confused between the two languages. Remember that Java is an entirely different language made for a different purpose (although you’ll still find it running on certain website backends).

Lastly, before we look at today’s itinerary, remember that JavaScript, just like HTML and CSS (but maybe even more so), is a vast language. We’ll only be learning parts of it that are relevant to us today, so we’ll list some good resources at the end if you’d like to learn more.

-------------------- ●●●--------------------

1. JavaScript basics

JavaScript is a programming language, and like most programming languages, it has some basic constructs that we’ll look at. A program in JavaScript is like a sequence of steps. Similar to how we give directions to a stranger, a computer needs detailed instructions, defined as steps, to accomplish any simple or complex action.

Let’s begin by looking at some basics.

Writing Javascript

We’ll create a new file for writing JavaScript called ‘script.js’ in the portfolio directory. Now open the index.html file, and just before the closing body tag (), insert this line.

<script src="script.js"></script>

That’s it. We have linked our script file in our HTML. Just to make sure it works, write the following code into your script.js file.

alert('hello world');

Save and refresh the page

Notice the dialog box at the top? That’s your first line of JavaScript, the alert code, executing. Try changing the text and refreshing. You can do that in the CodePen below too!

If you followed along with the last section, you have correctly set up the script file. We’re ready to write some JavaScript! Let’s have a look at some important concepts.

Variables

Variables are friendly names that hold data. Think of how you call a person by their name as opposed to ‘human’ or ‘one head, two eyes, one nose…’ and so on. Variables are simply human-friendly (and descriptive) names for pieces of data. Let’s consider an example.

let greeting = 'Hello world';

Here we’re defining a variable called ‘greeting’ and assigning it the value of ‘Hello world’. It almost reads like English–’let greeting be Hello world’–see? Now greeting holds the value ‘Hello world’ in it, and can be used instead of the literal text ‘Hello world’.

alert('hello world');

you could write:

let greeting = 'Hello World';
alert(greeting);

Refresh the page and the result should be the same. While it seems like we’re doing more to achieve the same result, in the real world, variables are immensely useful for storing data. Variables can also be used to store different types of data such as numbers, strings, and other variables..

let age = 32;
let pi = 3.142;
let alphabet = 'a';

Did you notice how we wrote ‘let’ before the actual variable name? That’s one way of declaring a variable in JavaScript. You can learn more in this Mozilla guide to declarations.

Also note how each line ends with a semicolon (;). This isn’t strictly needed (except for some specific cases), but it’s best practice to use them, so we recommend you do so.

Arithmetic Operators

JavaScript can also be used as a calculator. In fact, a lot of the code you’ll see in the wild will have basic calculations everywhere. It supports all the regular functions, called operators, like plus (+), minus (-), multiply (*), divide (/) and so on. You could do something like the following and it should say 5, just as you’d expect. Try running the CodePen below and you should see a popup in the current browser window.

alert(2+3);

Comparison Operators

Comparison operators compare two things together. In English and other languages, we often ask questions like ‘Is it warmer today than yesterday’ or ‘Are these two buildings of the same size?’. The answer to these questions is either a yes or a no, and they’re usually comparing two things (today vs yesterday, building 1 vs building 2 etc). In programming terms, it is either a ‘true’ or ‘false’.

We can ask questions like those in JavaScript too! In JavaScript, we have the following comparison operators:

Operator      Question in asks

===    Are the two things equal?*
!==    Are the two things unequal?  *
>=    Is the first thing greater 
than or equal to the second?
<=    Is the first thing less thanor equal to the second?
>    Is the first thing greater than the second?
<    Is the first thing less than the second?

*There are less strict variants of these, namely == and !=, which enable you to compare two things that may not be of the same type.

“1” == 1 is true, but “1” === 1 is not true, as “1” is a string, while 1 is a number.

We recommend you stick to strict equal/not equal (=== and !==), and avoid the use of == and !=

Functions

Functions are blocks of code to which we assign a name so that we can reuse them. Say adding two numbers is a common operation for our website. We can write the above code inside a function, as follows:

function add(number1, number2) { 
let sum = number1 + number2; 
return sum;
}

See how the function accepts two numbers (number1 and number2, formally called the parameters of the function), adds them, and ‘returns’ the result; in other words, sends the result back to you. Here we’ve defined how the ‘add’ function should behave, but we’re not using it. To use this code, we’ll need to ‘call’ it. Calling a function is simply writing its name and using parentheses to pass in the ‘arguments’ (actual parameters).

add(2, 3)

Let’s take another example. Consider a function that ‘alerts’ whatever is sent to it.

function alertMessage(message) {
alert(message);
}

In this function, alertMessage is the function name, message is the parameter and we have no return value (notice the missing return statement).

When we call it as alertMessage(‘Hello World’), the ‘Hello World’ part is the argument of the function. This is just the tip of the iceberg in the world of functions, but enough to get us moving.

Getting back to the add function, we’ll use it as follows:

function add(number1, number2) {
let sum = number1 + number2;
return sum;
}

let num1 = 2;
let num2 = 3;
let sum = add(num1, num2);
alert(sum);

Did it run okay? If not, look into the console and see if you have any syntactical errors.

Repeating what we said about variables, this might again seem like more work to do exactly the same thing, and you’d be right in saying that. However, this will help us prepare for something more than just adding two numbers together.

Flow control

Generally, a program in JavaScript will execute line by line. But there are instances when we wish to execute a statement based on some condition, or execute a group of statements multiple times. Such change in the order of execution of code is called flow control.

An example will make it clearer. Suppose you wish to show different messages to your users depending on whether they’re 18 and above or not. In plain English, your logic would be as follows:

If age is less than 18, display “You’re not an adult”, else, display “You’re an adult”

In JavaScript, you’d write the code as follows:

if(age < 18) { 
 alert("You’re not an adult");
} else { 
  alert("You’re an adult");
}

Notice how similar the plain English version is to the JavaScript code. What we just wrote is an example of an if..else statement. Notice the age < 18 part. That’s the condition. We’ve used the less than operator here from the Comparison Operators section above.

The general syntax of if..else is:

if(condition) { 
  // code to run if condition is true 
} else { 
  // code to run if condition is false
}

We’ll use if..else whenever we’ll need to make a decision in the code–for example, making sure our users have entered the right data.

Objects

The last important concept needed for our website is the JavaScript object. Objects are simply containers for key-value pairs, similar to what you’d find in a dictionary. In a dictionary, a key is a word and a value is the meaning of the word. In a JavaScript object, a key is a name, and a value can be anything, even other objects. Let’s look at an example:

let fullName = { 
  firstName: 'John', 
  lastName: 'Doe'
}

In our example object, which is called ‘fullName’, firstName and lastName are keys, and ‘John’ and ‘Doe’ are the values.

We can access the firstName by using the dot (.) notation. The following will show the alert ‘John’.

let fullName = { 
  firstName: 'John', 
  lastName: 'Doe'
}

alert(fullName.firstName);

As mentioned, objects can have other objects and functions inside of them.

We can send an alert, in this case with:

let personDetails = {
  fullName: {
    firstName: 'John',
    lastName: 'Doe' 
  },
  alertMessage: function(message) {
    alert(message);
  }
}


personDetails.alertMessage('Hello World');

2. Selecting HTML elements

The power of JavaScript on the web lies in its power to select and modify the HTML code. For example, we can write a function in JavaScript that gets called when we click the ‘submit’ button in our footer form.

To do that, let’s first select our submit button and attach a ‘click listener’ function to it. When we attach a click listener to an element, it will call that listener function when the button is clicked. To be able to select our button, we’ll give it an ID attribute with a unique ID in our HTML file.

<input type="submit" value="Send Message" id="submit-button" />

Now that we have an ID to select, let’s move to our JavaScript file and use a JavaScript function, document.querySelector() to select our element. Just like we could select HTML elements by their names, class attributes or IDs in CSS, we can the same in JavaScript using this function.

document.querySelector takes the selector as its parameter, and returns the HTML element that matched the selector, in the form of an Object (remember that Object are just containers for key-value pairs of data). We can then store this HTML element in a variable, and perform all sorts of operations on it.

let submitButton =  
document.querySelector('#submit-button');

Notice how the ID needs to be prefixed by the pound character (#), just like when you select IDs in CSS. If it were a class name you’d use (you guessed it) a period (.), like .submit-button

Pro tip: When in doubt, try console.log() to ‘log’–that is to display a certain message in the Chrome Developer Console–the variable in JavaScript. For example, after writing the previous line, try logging the submitButton variable with

 console.log(submitButton);

and check the output. If you see ‘undefined’ or ‘null’, it means something is incorrect.

In general, try tinkering with the developer tools. It takes time, but once you get the hang of it, figuring out what went wrong (‘debugging’) becomes easier.

3. Attaching a ‘click’ listener

Now that we have the HTML element selected and stored in a JavaScript variable, let’s add a click listener function to it. A click listener, as the name suggests, listens or waits for a click. We attach click listeners to certain elements that are of our interest–form submit buttons–for example. When the said HTML element is clicked, the click listener function gets called.

function clickListener() { 
  console.log('Button clicked'); 
} 

submit.addEventListener('click', clickListener);

Notice that the click listener function is just an ordinary function that we pass to the addEventListener() function (yes, passing functions to other functions as arguments is possible and very common in JavaScript!).

But before we try to run this, we’ll need to make some changes to the above code to make sure it runs properly.

You can also try running the CodePen snippet. Click the ‘Send Message’ button and then open the Developer Console in the same window as the one you’re reading this course in. You should see the text Button clicked in the console.

let submitButton = 
document.querySelector('#submit-button');

function clickListener(event) {
  event.preventDefault();
  console.log('Button clicked');
}


submitButton.addEventListener('click', clickListener);

Essentially, we’re taking the event parameter supplied to our function, which contains the details of the click event (like what was clicked, button properties, etc), and preventing the form from refreshing the page with event.preventDefault()

Save and reload. Open the Developer Tools, Console tab and try clicking the button.

Hurray!! It works.

Our next step is to get the values entered into the form using JavaScript.

4. Getting user entered values

We have a form on our webpage, but we haven’t talked about how we’ll extract the data that a user might enter in our form. To make any form ‘work’, we generally get the data (that is, text in our case) inside of the form elements (inputs, textareas etc) into JavaScript variables and then send it to the server. Optionally, many developers like to do some validations (that is, checks) on the data before sending it to the server. An example validation could be checking the format of the email entered.

Remember the document.querySelector we used in the previous section? We used it to select HTML elements. Since form inputs are nothing but HTML elements, and the data that a user might enter in those inputs is stored inside of the HTML elements, we could use the same document.querySelector and select our HTML elements.

Then, we need to know a crucial piece of information. An HTML input’s value, or the data inside of it, can be accessed via the ‘value’ key. Remember Objects? The HTML input element object will have a ‘value’ key that holds the current text inside of the element.

Finally, we’ll console.log the values from the input and textarea and see what we’re getting in the emailText and messageText variables.

function clickListener(event) { 
  event.preventDefault();

  let emailInput = 
document.querySelector('#email'); 
  let messageInput = 
document.querySelector('#message');

  let emailText = emailInput.value; 
  let messageText = messageInput.value;

  console.log('email:', emailText, 'message:', messageText);

Perfect! Did you see how the message just logs, flawlessly? Beautiful, we say. Instead of just printing the emailText and messageText, we’ve formatted it a bit using console.log('email:', emailText, …) which will print it nicely with the label email: printed as is.

It is possible that you might see some errors at this point. Just go back and make sure you type it exactly as it is. Play around and try different inputs. Did you notice any issues?

Pro tip: It is important to make mistakes. You should get used to seeing error messages and knowing what they mean. It might feel a bit cryptic in the beginning, but practice is the key. So whether you get it right straight away or after a bit of trying, there’s always something to be learned.

5. JavaScript validations

If you played around a bit in the previous section, you’ll have noticed something weird. Although the input fields say email and message, you can pretty much enter anything into it and it would still accept and print it.

In fact, it even allows you to enter empty an empty email address and message. That’s not good. We’ll need to set some restrictions for what gets entered, especially the email field. For our purposes, checking to see if the text entered in the email field has an ‘@’ character will do. In the real world, you’ll want to do more stringent checks on the data.

For validating email, we need to write a validation function. Validation, as mentioned in the previous section, are checks. They could be checks to make sure the data is in the format we expect, or to filter any unwanted words from the text, or anything else. They serve as an easy way to let the users know about any errors in their data submissions.

In our email address validation example, our check for ‘@’ might catch the instance where our users forget to type ‘@’ or mistype their email addresses.

function emailValidate(email) { 
  if(email.includes('@')) { 
    return true;
  } else { 
    return false;
  }
}

This function checks if the supplied text parameter email contains the ‘@’ character. It’s using something called a conditional (the ‘if’ and ‘else’ that you see). You can read it as, if yes, it returns true. Otherwise, it returns false. Let’s test it in our clickListener function by logging it to the console.

 console.log(emailValidate('abc@xyz.cm'));

Okay, it works! It isn’t perfect, but it does demonstrate how expressive JavaScript is. Now we can bring everything together inside our clickListener function and display the appropriate message.

if(emailValidate(emailText) !== true) { console.log('The email address must contain @'); return false; } console.log('Thanks for your message');

Try it and view the results in your browser’s Developer Tools console.

function emailValidate(email) {
  if(email.includes('@')) {
return true;
  }
  else {
    return false;
  }
}

Here, we’re first checking the email. If it fails, we log the error message and return false (which is one way of preventing further execution of a function, meaning that our last console.log will not be executed).

If the ‘if’ block are not executed (which means return false wasn’t encountered and the function is still running), we assume all went well and display a success message. Pretty sweet, huh?

Did you get it right? Great job! If not, just look carefully. You’ll find the bug. Remember, debugging is a critical developer skill!

Thanks for getting to the end of this article

CONTACT ME

● Telegram

● Instagram

https://buymeacoffee.com/musprodev

What is CDN ?

A content delivery network (CDN) refers to a geographically distributed group of servers which work together to provide fast delivery of Internet content.

A CDN allows for the quick transfer of assets needed for loading Internet content including HTML pages, javascript files, stylesheets, images, and videos. The popularity of CDN services continues to grow, and today the majority of web traffic is served through CDNs, including traffic from major sites like Facebook, Netflix, and Amazon.

A properly configured CDN may also help protect websites against some common malicious attacks, such as Distributed Denial of Service (DDOS) attacks

Is a CDN the same as a web host?

While a CDN does not host content and can’t replace the need for proper web hosting, it does help cache content at the network edge, which improves website performance. Many websites struggle to have their performance needs met by traditional hosting services, which is why they opt for CDNs.

By utilizing caching to reduce hosting bandwidth, helping to prevent interruptions in service, and improving security, CDNs are a popular choice to relieve some of the major pain points that come with traditional web hosting.

What are the benefits of using a CDN?

Although the benefits of using a CDN vary depending on the size and needs of an Internet property, the primary benefits for most users can be broken down into 4 different components:

• Improving website load times - By distributing content closer to website visitors by using a nearby CDN server (among other optimizations), visitors experience faster page loading times. As visitors are more inclined to click away from a slow-loading site, a CDN can reduce bounce rates and increase the amount of time that people spend on the site. In other words, a faster a website means more visitors will stay and stick around longer.

• Reducing bandwidth costs - Bandwidth consumption costs for website hosting is a primary expense for websites. Through caching and other optimizations, CDNs are able to reduce the amount of data an origin server must provide, thus reducing hosting costs for website owners.

• Increasing content availability and redundancy - Large amounts of traffic or hardware failures can interrupt normal website function. Thanks to their distributed nature, a CDN can handle more traffic and withstand hardware failure better than many origin servers.

• Improving website security - A CDN may improve security by providing DDoS mitigation, improvements to security certificates, and other optimizations.

How does a CDN work?

At its core, a CDN is a network of servers linked together with the goal of delivering content as quickly, cheaply, reliably, and securely as possible. In order to improve speed and connectivity, a CDN will place servers at the exchange points between different networks.

These Internet exchange points (IXPs) are the primary locations where different Internet providers connect in order to provide each other access to traffic originating on their different networks. By having a connection to these high speed and highly interconnected locations, a CDN provider is able to reduce costs and transit times in high speed data delivery.

Beyond placement of servers in IXPs, a CDN makes a number of optimizations on standard client/server data transfers. CDNs place Data Centers at strategic locations across the globe, enhance security, and are designed to survive various types of failures and Internet congestion.

Latency - How does a CDN improve website load times?

When it comes to websites loading content, users drop off quickly as a site slows down. CDN services can help to reduce load times in the following ways:

• The globally distributed nature of a CDN means reduce distance between users and website resources. Instead of having to connect to wherever a website’s origin server may live, a CDN lets users connect to a geographically closer data center. Less travel time means faster service.

• Hardware and software optimizations such as efficient load balancing and solid-state hard drives can help data reach the user faster.

• CDNs can reduce the amount of data that’s transferred by reducing file sizes using tactics such as minification and file compression. Smaller file sizes mean quicker load times

• CDNs can also speed up sites which use TLS/SSL certificates by optimizing connection reuse and enabling TLS false start.

Explore all the ways a CDN helps websites load faster

Reliability and Redundancy - How does a CDN keep a website always online?

Uptime is a critical component for anyone with an Internet property. Hardware failures and spikes in traffic, as a result of either malicious attacks or just a boost in popularity, have the potential to bring down a web server and prevent users from accessing a site or service. A well-rounded CDN has several features that will minimize downtime:

• Load balancing distributes network traffic evenly across several servers, making it easier to scale rapid boosts in traffic.

• Intelligent failover provides uninterrupted service even if one or more of the CDN servers go offline due to hardware malfunction; the failover can redistribute the traffic to the other operational servers.

• In the event that an entire data center is having technical issues, Anycast routing transfers the traffic to another available data center, ensuring that no users lose access to the website.

Learn more about how a CDN helps keep websites online

Data Security - How does a CDN protect data?

Information security is an integral part of a CDN. a CDN can keep a site secured with fresh TLS/SSL certificates which will ensure a high standard of authentication, encryption, and integrity. Investigate the security concerns surrounding CDNs, and explore what can be done to securely deliver content. Learn about CDN SSL/TLS security

Bandwidth Expense - How does a CDN reduce bandwidth costs?

Every time an origin server responds to a request, bandwidth is consumed. See how a CDN, like the Cloudflare CDN, cuts down on origin requests and reduces bandwidth costs.

Subscribe to my newsletter for more articles

Who Is This For

This study plan is for you if:

• You’re already familiar with basic programming concepts like variables and functions.
• You might have already done back-end work with languages such as PHP and Python, and maybe used front-end libraries such as jQuery for a few simple hacks.
• You now want to get into more serious front-end development but are drowning in frameworks and libraries before you’ve even started.

Things We’ll Cover

• What a modern JavaScript web app looks like
• Why you can’t just use jQuery
• Why React is the safest pick
• Why you may not need to “learn JavaScript properly” first
• How to learn ES6 syntax
• Why and how to learn Redux
• What GraphQL is and why it’s a big deal
• Where to go next

Resources Mentioned Here

Disclaimer: this post will include a few affiliate links to courses by Wes Bos, but the material is recommended because I genuinely think it’s good, and not just because of the affiliate scheme. If you would rather find other resources, Mark Erikson maintains a great list of React, ES6, and Redux links.

JavaScript vs JavaScript

Before we start, we need to make sure we’re talking about the same thing. If you google “Learn JavaScript” or “JavaScript study plan”, you’ll find a ton of resources that teach you how to learn the JavaScript language.

But that’s actually the easy part. While you can definitely dig deep and learn the intricacies of the language, the truth is most web apps use relatively simple code. In other words, 80% of what you’ll ever need to write web apps is typically covered in the first few chapters of your typical JavaScript book.

No, the hard problem is mastering the JavaScript ecosystem, with its countless competing frameworks and libraries. The good news is, that’s exactly what this study plan focuses on.

The Building Blocks Of JavaScript Apps

In order to understand why modern JavaScript apps seem so complex, you first have to understand how they work.

For starters, let’s look at a “traditional” web app circa 2008:

1. The database sends data to your back-end (e.g. your PHP or Rails app).
2. The back-end reads that data and outputs HTML.
3. The HTML is sent to the browser, which displays it as the DOM (basically, a web page)

Now a lot of these apps also sprinkled in some JavaScript code on the client to add interactivity, such as tabs and modal windows. But fundamentally, the browser was still receiving HTML and going from there.

Now compare this with a “modern” 2016 web app (also known as the “Single Page App”):

Notice the difference? Instead of sending HTML, the server now sends data, and the “data to HTML” conversion step happens on the client instead (which is why you’re also sending along the code that tells the client how to perform said conversion).

This has many implications. First, the good:

• For a given piece of content, sending only data is faster than sending entire HTML pages.

• The client can swap in content instantly without having to ever refresh the browser window (thus the term “Single Page App”).

The Bad:

• The initial load takes longer since the “data to HTML” codebase can grow quite large.

• You now need a place to store and manage the data on the client too, in case you want to cache it or inspect it.

And the ugly:

• Congratulations — you now have to deal with a client-side stack, which can get just as complex as your server-side stack.

The Client-Server Spectrum

So why go through all this trouble if there are so many downsides? Why not just stick to the good old PHP apps of old?

Well, imagine you’re building a calculator. If the user wants to know what 2 + 2 is, it doesn’t make sense to go all the way back to the server to perform the operation when the browser is perfectly capable of doing it.

On the other hand, if you’re building a purely static site such as a blog, it’s perfectly fine to generate the final HTML on the server and be done with it.

The truth is, most web apps fall somewhere in the middle of the spectrum. The problem is knowing where.

But the key thing is that the spectrum is not continuous: you can’t start with a pure server-side app and slowly move towards a pure client-side app. At some point (the Divide), you’ll be forced to stop and refactor everything, or else end up with a mess of unmaintainable spaghetti code.

This is why you shouldn’t “just use jQuery” for everything. You can think of jQuery like duct tape. It’s amazingly handy for small fixes around the house, but if you keep adding more and more things will start looking ugly.

On the other hand, modern JavaScript frameworks are more like 3D-printing a replacement piece: it takes more time, but the result is a lot cleaner and sturdier.

In other words, mastering the modern JavaScript stack is a bet that no matter where they start, most web apps will probably end up on the right side of the divide sooner or later. So yes, it’s more work, but better safe than sorry.

Week 0: JavaScript Basics

Unless you’ve a pure back-end developer, you probably know some JavaScript. And even if you don’t, JavaScript’s C-like syntax will look somewhat familiar if you’re a PHP or Java developer.

But if JavaScript is a complete mystery to you, don’t despair. There are a lot of free resources out there that will quickly bring you up to speed. For example, a good place to start is Codecademy’s JavaScript lessons.

Week 1: Start With React

Now that you know basic JavaScript syntax, and that you understand why JavaScript apps can appear so complex, let’s talk specifics. Where should you start?

React is a UI library created and open-sourced by Facebook. In other words, it takes care of that “data to HTML” step (the View Layer).

Now don’t get me wrong: I’m not telling you to pick React because it’s the best library out there (because that’s highly subjective), but because it’s pretty good.

• React might not be the most popular library, but it’s pretty popular.
• React might not be the most lightweight library, but it’s pretty lightweight.
• React might not be the easiest to learn, but it’s pretty easy to learn.
• React might not be the most elegant library, but it’s pretty elegant.

In other words, React might not be the best choice in every situation, but I believe it’s the safest. And believe me, “just when you’re starting out” is not the right time to take risks with your technological choices.

React will also introduce you to some useful concepts like components, application state, and stateless functions that will prove useful no matter which framework or libraries you end up using during your career.

Finally, React has a large ecosystem of other packages and libraries that work well with it. And its sheer popularity means you’ll be able to find a lot of help on sites like Stack Overflow.

I personally recommend the React for Beginners course by Wes Bos. It’s how I learned React myself, and it’s just been completely overhauled with the latest React best practices.

Should You “Learn JavaScript Properly” First?

If you’re a very methodical learner, you might want to get a good grasp of the fundamentals of JavaScript before you do anything else.

But for others, this feels like learning to swim by studying human anatomy and fluid dynamics. Sure, they both play a huge role in swimming, but it’s more fun to just jump in the pool!

There’s no right or wrong answer here, it all depends on your learning style. The truth is, most basic React tutorials will probably use only a tiny subset of JavaScript anyway, so it’s perfectly fine to focus on only what you need now and leave the rest for later.

This also applies to the JavaScript ecosystem at large. Don’t worry too much about understanding the ins and outs of things like Webpack or Babel for now. In fact React recently came out with its own little command-line utility that lets you create apps with no build configuration whatsoever.

Week 2: Your First React Project

Let’s assume you’ve just completed a React course. If you’re like me, two things are probably true:

• You’ve already forgotten half of what you just learned.
• You can’t wait to put the half you do remember in practice.

I believe the best way to learn a framework or a language is to just use it. And personal projects are the perfect occasion to try out new technologies.

A personal project could be anything from a single page to a complex web app, but I feel like redesigning your own personal site can be a good middle ground. Plus, I know you’ve probably been putting it off for years!

Now I did say earlier that using single-page apps for static content was often overkill, but React actually has a secret weapon: Gatsby, a React static site generator that lets you “cheat” and get all the benefits of React without any of the downsides

Here’s why Gatsby is a great way to get started with React:

• A pre-configured Webpack, meaning you get all the benefits without any of the headaches.
• Automatic routing based on your directory structure.
• All HTML content is also generated server-side, so you get the best of both worlds.
• Static content means no server and super-easy hosting on GitHub Pages.

I used Gatsby for the State Of JavaScript site, and not having to worry about routing, build tool configuration, or server-side rendering saved me a ton of time.

Week 3: Mastering ES6

In my own quest to learn React, I soon reached a point where I could get by copy-pasting code samples, but there was still a lot I didn’t understand.

Specifically, I was unfamiliar with all the new features introduced by ES6, such as:

• Arrow functions
• Object destructuring
• Classes
• The spread operator

If you’re in the same boat, it might be time to take a couple days and learn ES6 properly. If you enjoyed the React for Beginners course, you might want to check out Wes’ excellent ES6 for Everybody videos.

Or if you prefer free resources, check out Nicolas Bevacqua’s book, Practical ES6.

A good exercise for mastering ES6 is going through an older codebase (such as the one you just created in Week 2!) and converting your code to ES6's shorter, terser syntax whenever possible.

Week 4: Taking On State Management

As this point you should be capable of building a simple React front-end backed by static content.

But real web apps are not static: they need to get their data from somewhere, generally a database of some kind.

Now you could just send data to your individual components, but that quickly gets messy. For example, what if two components need to display the same piece of data? Or need to talk to each other?

This is where State Management comes in. Instead of storing your state (in other words, your data) bit by bit in each component, you store it in a single global store that then dispatches it to your React components:

In the React world, the most popular state management library is Redux. Redux not only helps centralize your data, but it also enforces some strict protocols for manipulating this data.

You can think of Redux as a bank: you can’t go to your local branch and manually modify your account total (“here, let me just add a couple extra zeroes!”). Instead, you fill out a deposit form, then give it to a bank teller authorized to perform the action.

Similarly, Redux also won’t let you modify your global state directly. Instead, you pass actions to reducers, special functions that perform the operation and return the new, updated state as a result.

The result of all this extra work is a highly standardized and maintainable data flow throughout your app, and access to tools such as the Redux Devtools to help you visualize it:

Once again you can stay with our friend Wes and learn Redux with his Redux course, which is actually completely free!

Or, you can check out Redux creator Dan Abramov’s video series on egghead.io, which is free as well.

Bonus Week 5: Building APIs With GraphQL

So far we’ve pretty much only talked about the client, and that’s only half the equation. And even without going into the whole Node ecosystem, it’s important to address one key aspect of any web app: how data gets from the server to the client.

It won’t come as a surprise that this, too, is rapidly changing, with GraphQL (yet another Facebook open-source project) emerging as a serious alternative to the traditional REST APIs.

Whereas a REST API exposes multiple REST routes that each give you access to a predefined dataset (say, /api/posts, /api/comments, etc.), GraphQL exposes a single endpoint that lets the client query for the data it needs.

Think of it as making multiple trips to the butcher shop, bakery, and grocery store, versus giving someone a shopping list and sending them on their way to all three.

This new strategy becomes especially significant when you need to query multiple data sources. Just like with our shopping list example, you can now get data back from all these sources with a single request.

GraphQL has been picking up steam over the past year or so, with many projects (such Gatsby, which we used in Week 2) planning on adopting it.

GraphQL itself is just a protocol, but its best implementation right now is probably the Apollo library, which works well with Redux. There is still a lack of instructional material around GraphQL and Apollo, but hopefully the Apollo documentation can help you get started.

Beyond React & Co

I recommended you start with the React ecosystem because it’s a safe pick, but it’s by no means the only valid front-end stack. If you want to keep exploring, here are two recommendations:

Vue

Vue is a relatively new library but it’s growing at record speeds and has already been adopted by major companies, especially in China where it’s being used by the likes of Baidu and Alibaba (think Chinese Google and Chinese Amazon). And it’s also the official front-end layer of PHP framework Laravel.

Compared to React, some of its key selling points are:

• Officially-maintained routing and state management libraries.
• Focus on performance.
• Lower learning curve thanks to using HTML-based templates.
• Less boilerplate code.

As it stands, the two main things that still give React an edge over Vue are the size of the React ecosystem, and React Native (more on this later). But I wouldn’t be surprised to see Vue catch up soon!

Elm

If Vue is the more approachable option, Elm is the more cutting-edge one. Elm is not just a framework, but an entire new language that compiles down to JavaScript.

This brings multiple advantages, such as improved performance, enforced semantic versioning, and no runtime exceptions.

I haven’t tried Elm personally, but it’s been warmly recommended by friends and Elm users generally seem very happy with it (as shown by its 84% satisfaction rating in the State Of JavaScript survey).

Next Steps

By now you should have a pretty good grasp of the entire React front-end stack, and hopefully be reasonably productive with it.

That doesn’t mean you’re done though! This is only the beginning of your journey through the JavaScript ecosystem. Some of the other topics you’ll eventually run into include:

• JavaScript on the server (Node, Express…)
• JavaScript testing (Jest, Enzyme…)
• Build tools (Webpack…)
• Type systems (TypeScript, Flow…)
• Dealing with CSS in your JavaScript apps (CSS Modules, Styled Components…)
• JavaScript for mobile apps (React Native…)
• JavaScript for desktop apps (Electron…)

I can’t cover all this here but don’t despair! The first step is always the hardest, and guess what: you’ve just taken it by reading this study plan.

And now that you understand how the various pieces of the ecosystem fit together, it’s just a matter of lining up what you want to learn next and knocking down a new technology each month.

Keep In Touch

Did you find this study plan helpful? Which area of JavaScript would you like me to write about next? Leave a comment or telegram me to let me know!

And if you want to know next time I publish a post, you can also sign up to my newsletter.

Or maybe you are curious to learn what all this coding craze is about so you can get started developing apps and websites yourself.

If that's the case, then this article can help you figure out where to start.

Why – and How – Should You Teach Yourself Coding?

Coding is a field that is accessible to everyone. And to get a tech job, you don't necessarily need a degree from an expensive university. As long as you are able to show that you are good at coding, you can get a job.

Tech is so accessible partly because of all the free resources you can use to teach yourself to code. But this can also be a challenge: how do you navigate through all these courses, articles, bootcamps, and discussion threads?

It's usually a good idea to choose one main resource from which to start learning. It can be a curriculum or an ordered list of topics, whatever works for you. Then follow that plan.

It's ok to make brief detours and use other materials that might help you out when you're stuck, but try to do that only if the resources you have are not enough.

When you finish a curriculum or a course, you may be tempted to start another one on the same topic right away. But instead of doing that, you should build projects with what you just learned to learn it better.

You will likely have enough basic knowledge to build simple projects, and in the process you'll figure out what you know and don't know.

To help you find some learning resources that are right for you, in this article I'll share various websites where you can learn to code for free.

I've used most these tools myself while learning to code, and I use some of them even now. And if I haven't personally used them, I made sure to choose resources that have really positive feedback.

freeCodeCamp.org

If you are here, you may have noticed that this is freeCodeCamp's publication. Here at freecodecamp.org/news there are thousands of articles on programming and related topics that you may find really useful along your learning path.

You can bookmark these articles to help you learn new topics or find different explanations for topics you are struggling with.

Also, the freeCodeCamp learning platform has a full-stack web development curriculum based on the MERN stack (Mongo, Express, React, NodeJS), and an expanding curriculum on Python and Data Science.

The freeCodeCamp forum is also a really friendly place to get help with the curriculum and programming help in general.

Finally, the FreeCodeCamp YouTube channel has thousands of hours of video tutorials on various programming topics. It has a much wider variety of topics than the curriculum, so if you are not interested in web devoplment, or want to look at other specific topics in more detail, definitely check the YouTube channel out.

Khan Academy

Khan Academy offers courses in a lot of subjects, including introductory courses on programming and computer science.

It teaches JavaScript, HTML, CSS and SQL basics through interactive walkthroughs, with visual representations of the code changes. It's a great place to start if you're a total beginner.

The Odin Project

The Odin Project's full stack curriculum is free and supported by an open source community. It teaches you how to set up your own environment, and focuses on Ruby, Ruby on Rails, HTML, CSS, JavaScript, and NodeJS.

The curriculum contains dozens of assignments that'll help you build portfolio-worthy projects. And you can connect with the friendly community of beginners and experienced developers.

Grasshopper

Grasshopper is a coding app for beginners. It is a phone app that uses fun quick lessons of increasing difficulty to teach you to write real JavaScript.

Grasshopper can be an ever present companion, always in your pocket, while you build your fundamentals. It can help get you ready for your next steps in learning web development.

MitOpenCourseware

The MitOpenCourseware video courses section on Computer Science and Electrical Engineering offers a lot of video courses at the Graduate and Undergraduate level to improve your theoretical knowledge of computer science topics.

It covers areas like data structures, algorithms, artificial intelligence, and much more.

Harvard University's Free Online Courses

Harvard University's free online course catalogue has many interesting Computer Science courses on many subjects.

There are introductory courses to Computer Science and Programming using Scratch, an introductory course to Technology in general, and courses on Machine Learning, among other topics.

Code.org

Code.org has courses for all ages, but it's mostly directed toward young students (and teachers who want to teach coding to their students).

It offers various Hour of Code projects (projects that you can complete in one hour), and has a lot of material for self-learners, teachers, and students in a lot of different languages.

HackInScience

HackInScience is an interactive Python exercise platform, where you can learn Python and strengthen your Python skills.

Each exercise has links to guides for the features of the language you need to apply in that exercise that you didn't need in the previous exercises – so it helps you build upon what you've learned.

GitHub Guides

GitHub Guides is the official collection of guides from GitHub that help you learn how to work with Git and GitHub.

The guides include detailed explanations, with images and gifs, of GitHub issues, GitHub Pages, how to fork projects, a Git Handbook, and more.

MDN Learn Web Development and Tutorials

MDN Learn Web Development aims to bring its learners from absolute beginners to a level where they're comfortable with programming basics. Their aim is to help you get to a point where you're able to learn on your own from other sources.

In this area of the MDN website there is also a Front-end web developer learning pathway with material for hundreds of hours of learning.

Thank you for reading!

Now you have a collection of great beginner-friendly resources that'll help you start learning to code. Good luck!

Don't forget to subscribe to my newsletter

When you’re about to start your career in IT Industry, you have so many options to starts with. There are so many programming languages, frameworks, and libraries like HTML, CSS, JavaScript, TypeScript, Java, Python, React, Angular, C#, C++, PHP, and so many others. Because of these so many options, you get confused to pick a path to starts with.

To be honest, if you have been confused and feel overwhelmed, you’re not alone. I have been there too. Now I realized that I had made some mistakes during my journey from fresher to senior software engineer. And I know that too that I’m not alone who made those mistakes. Because I don’t have much clarity as to where and how I can starts, I had spent a lot of time on unnecessary things.

One of the mistakes that most beginners make is that they waste so much time jumping from one thing to another and they don’t learn anything. So in this article, I’m gonna give you a clear and solid learning path to start with Front End Development so that you spend your time on things that matter the most.

●●●●●●●●●●●○●●●●●●●●●●

1. Foundation

First thing first. To become a front-end developer, you need to start with HTML, CSS, and JavaScript. These are actually the fundamental languages for front-end development. HTML is used to structure our web pages, CSS to make them beautiful, and JavaScript to program them.

Let’s understand this with an analogy. Think of a building as a web page. It has a skeleton or structure (HTML), it has pretty walls with paint and tiles (CSS) and it can have certain functionalities, e.g. when we press the elevator button, it comes to pick us up (JavaScript). Now, let’s take another example. Just have a look at your medium profile page. The header looks something like this.

You want to develop a header that looks like it. So first we use HTML to build all the building blocks of this layout. Building blocks like user name, number of followers, lists menu, and about menu on the left side, and a search icon, a dropdown with profile image, a button to write a new story, and a medium icon to go to the medium’s home page on the right side. We use HTML to add these building blocks to our web page.

Then, we use CSS to give it some visual effects. For e.g, we make the user name a bit bigger and bold, change the color for the number of followers and other menus on the left side, and give the profile image a green border, changes text color and border color for the button, and justify the size of the medium icon.

And finally, we can use JavaScript to add functionality to our web page. Just like, if we click on the search icon, it can expand to some extent. We might use JavaScript for this.

So, every web page you see on the internet is built using these three languages; HTML, CSS, and JavaScript. So better you learn and understand these languages and their features, the better you will at front-end development.

2. Front End Frameworks

Now, we understand the importance of fundamentals and what we learn to ace them. What’s next? Well, building websites often include a bunch of repetitive tasks. And that’s where front-end frameworks and libraries come. A framework or library comes with a lot of code that we can reuse in our website. So, they help us to get the job done very faster. That’s why, nowadays a lot of companies use one of these popular frameworks like React, Angular, And Vue.

To be more accurate, React is not a framework but a library. The main difference between a framework and a library is that a framework forces our application into a structure. So all the applications build-up using a framework like Angular, end up having a similar structure. So as you move from one project to another, you will find a similar structure. On the other hand, Libraries don’t force our application into a structure. They just provide some code to reuse.

But settle all these things aside, all these tools serve the same purpose; they help us build applications faster. Now, you don’t need to learn all of those. As you move into different jobs, you might need to learn any one of those. Out of all these, React is the most popular. It’s built by Facebook and used to build Facebook and Instagram. So I would say go for React as a starting point.

3. Version Control Systems

We use version control systems to track our code history and work more collaboratively with others. That’s why you will find it in every job description. There are multiple version control systems available in the market, but git is the most popular one. So just focus on git, and don’t worry about other version control systems.

4. CSS Preprocessors

CSS is kind of an old language and it has its own limitations. If you write CSS for medium or large-size applications, sooner or later, your code starts looking messy and it becomes really hard to manage. So every time you want to change something, you end up breaking something else.

Now you will wonder why CSS hasn’t evolved. Well, it has and currently, it is at version 3. But every time there is a new feature in CSS, all the browsers need to support that feature. Which is, unfortunately, is a slow process. So this is where CSS Preprocessor comes in.

A CSS preprocessor is a program or tool that lets you generate CSS from a different language that is better and more capable than CSS. So instead of using plain CSS, we use another language that looks pretty similar to CSS. In fact, it's almost identical, but it has some extra features. Then we give our code to a CSS preprocessor that converts it into plain CSS which every browser understands. That’s the purpose of CSS preprocessors. There are many CSS preprocessors available like SASS, LESS, and Stylus to name a few. But again, you don’t have to learn them all to get a front-end developer job. Because these all are similar tools that serve the same purpose. SASS is the most popular among them. So I would recommend going with SASS.

5. Superset of JavaScript

Just like CSS, JavaScript is also a fairly old language. Although it’s getting updated from time to time, it still does have some limitations. So, a lot of front-end developers prefer more modern languages like TypeScript and CoffeeScript to write code. Then they give their code to a program called Transpiler which will translate and compile the modern code into old JavaScript code that all browsers can understand.

Once again, you don’t need to learn all of them. You just need to get started with any one of them. I would say, go with TypeScript, as this is the most popular and most widely used. As you move jobs, you might have to learn a different language. But you can learn those languages very easily because all of these languages are very similar as they are all built over JavaScript itself.

Learning Path

As we have already know what we have to learn for being a front-end web developer. Now, let’s see the exact path and the time which every step might consume.

First, you have to learn HTML, CSS, and JavaScript. If you spend 3–5 hours learning and coding, you would have a reasonable understanding of fundamentals in 3 months. You’re not going to be an expert, but you will understand them well enough to make things. Next, you have to learn a front-end framework or library like React.You would need 1–2 months to learn React.

After that, you have to learn a version control system like git. You would feel comfortable with git in 2 weeks.

These are the absolute essentials that you would find in almost every job description. Now, if you have some extra time, I would recommend learning SASS and TypeScript to stand out from the rest of the crowd and increase your job opportunities. SASS is pretty easy and you would need a week or two to learn it. TypeScript requires a bit more time it would need 2–4 weeks to learn the fundamentals of TypeScript.

So if you spend few hours studying and coding, you would be able to apply for junior front-end developer jobs after six months. Off-course, everyone is different. You might get there faster or you might take a bit longer, don’t let that discourage you. Don’t forget, you can achieve anything if you’re determined and passionate about it. To learn these skills, you can go to the websites like Udemy or Pluralsight. They have a lot of learning content. Just check the preview and rating of the course and choose any one of them which you like.

Conclusion

This is it for this article. I hope you have more clarity now about what it takes to be a front-end web developer. To read more articles like this, stay tuned! Thanks for reading!

Don't forget to subscribe to my newsletter for more articles

window.prompt() instructs the browser to display a dialog with an optional message prompting the user to input some text, and to wait until the user either submits the text or cancels the dialog.

Under some conditions — for example, when the user switches tabs — the browser may not actually display a dialog, or may not wait for the user to submit text or to cancel the dialog.

Syntax

 result = window.prompt(message, default);

Parameters

message Optional A string of text to display to the user. Can be omitted if there is nothing to show in the prompt window.

default Optional A string containing the default value displayed in the text input field. Note that in Internet Explorer 7 and 8, if you do not provide this parameter, the string "undefined" is the default value.

Return Value

A string containing the text entered by the user, or null.

Example

    let sign = prompt("What's your sign?");

    if (sign.toLowerCase() == "scorpio") {
    alert("Wow! I'm a Scorpio too!");
   }

    // there are many ways to use the prompt feature
     sign = window.prompt(); // open the blank prompt window
     sign = prompt();       //  open the blank prompt window
     sign = window.prompt('Are you feeling lucky'); // open the window with Text "Are you feeling lucky"
     sign = window.prompt('Are you feeling lucky', 'sure'); // open the window with Text "Are you feeling lucky" and default value "sure"

When the user clicks the OK button, text entered in the input field is returned. If the user clicks OK without entering any text, an empty string is returned. If the user clicks the Cancel button, this function returns null.

The above prompt appears as follows (in Chrome on OS X):button

Notes

A prompt dialog contains a single-line textbox, a Cancel button, and an OK button, and returns the (possibly empty) text the user entered into that textbox.

The following text is shared between this article, DOM:window.confirm and DOM:window.alert Dialog boxes are modal windows; they prevent the user from accessing the rest of the program's interface until the dialog box is closed. For this reason, you should not overuse any function that creates a dialog box (or modal window).

Please note that result is a string. That means you should sometimes cast the value given by the user. For example, if their answer should be a Number, you should cast the value to Number.

  const aNumber = Number(window.prompt("Type a number", ""));

Subscribe to my newsletter

Types of Hackers

There are mainly three types of Hackers available. First one is Black-Hat Hackers and the second one is White-Hat and the third one is Grey-Hat. The Black-Hat are those hackers who used their skills to do illegal work like stealing someone’s data, money, attacking on websites, etc. The White-Hat Hackers are those hackers who used their skills to protect systems/cyber word from malicious attacks or Hackers. The Grey-Hat Hackers is works in both manner, or you can say this is the mixture of both Black and White.

What is Cyber Security ?

You can relate this term with White-Hat Hackers because they provides security to cyber world. They protects system, server, websites, etc, from malicious attacks.

Career Opportunities

Cyber Security is a growing carrier in India and in some other countries also. If you have interested in this field then this is very good idea. If you can make yourself perfect then you can also get job in Cyber Cell . Because Cyber Security is need of every organization nowdays. Lots of companies hire Experts at a high salary package in India and also in other countries for making his server secure.

Subscribe to our newsletter

Those data types, and how to use them in Python 3, are the topic of this blog post series. Today, we're starting with strings.

If you're learning Python, you might also want to check out TwilioQuest 3. You'll learn about basic data types and much more about Python programming.

Ready to learn how to use strings in Python 3? Let's get started!

Strings in Python 3

One of the most common data types in any programming language is a string. A string represents a series of characters, which you would use to represent usernames, blog posts, tweets, or any text content in your code. You can create a string and assign it to a variable like this.

    my_name = "Jonathan Joestar"

Strings are "immutable"

In Python, strings are considered immutable - once you create them, they can't be changed. You can, however, use a variety of methods to create new strings from existing strings. This type of work in programming is called string manipulation. Some web developers joke that at the end of the day, their job is just mashing strings together - and this isn't far from the truth!

Here are some common tasks you might undertake when using strings in your code.

Common task - combining strings together

Combining strings together - concatenating them - is a very common task. In Python 3, you can use the + operator for this purpose. You can use the + operator multiple times to concatenate multiple strings.

    first_name = "Jonathan"
    last_name = "Joestar"

    full_name = first_name + " " + last_name

Common task - inserting data into strings

Another common task with strings is inserting data into a specific place within a string. In programming, we call this string interpolation. Python 3 provides a handy tool for doing this called "f" strings. The "f" in "f strings" stands for format - you can insert other data from your program into a string when you define it rather than doing complex string concatenation as demonstrated previously.

Here is an example of creating a formatted string - note the letter f is included just before the first double quote when defining the message variable. When you want to insert data from your program into the string, you can include it between two "curly braces" - the { and } characters.

  first_name = "Jonathan"
  last_name = "Joestar"
  age = 24

  message = f"My name is {first_name} {last_name}, and I am {age} years old."
  print(message)

Common task - using built-in string methods to manipulate strings

String objects have a number of methods to perform common tasks, like changing the case of strings or trimming their content. Below, you'll find a few examples. In two of these examples, we are creating a string variable, and then assigning the same variable a new value, which is the result of calling a method on a string object.

Example 1: Convert a string to all caps using the upper method.

  example_string = "am I stoked enough yet?"
  example_string = example_string.upper()
  print(example_string) # prints "AM I STOKED ENOUGH YET?"

Example 2: Replace all instances of the word kale with tacos.

  example_string = "We're having kale for dinner! Yay kale!"
  example_string = example_string.replace("kale", "tacos")
  print(example_string) # prints "We're having tacos for dinner! Yay tacos!"

Example 3: Split a comma-delimited string into a list of strings.

  example_string = "Apples,Oranges,Pears"
  groceries = example_string.split(',')

  # Code below prints:
  # Apples
  # Oranges
  # Pears
  for item in groceries:
   print(item)

Check our more strings can do in the Python 3 docs

Type casting

Frequently, you will want to convert data from one type into another. In programming, we call this process type casting. There are a number of functions built in to Python which allow us to do these type conversions on basic data types.

Example 1: Convert a number into a string using the str function.

 example_number = 42
 converted = str(example_number)
 message = "The meaning of life is " + converted

Example 2: Convert a string into a whole number (integer) using int.

  example_string = "2"
  converted = int(example_string)
  message = f"Two plus two equals { converted + 2 }"

Wrapping up

Strings of text are one of the most common pieces of data you will work with in programming. Hopefully, you've learned a bit about how to work with strings in Python 3! Stay tuned for more blog posts in this series to learn more about basic data types like strings, numbers, booleans, lists, and dictionaries.

Also, be sure to download and play TwilioQuest 3 to learn even more about Python!

In simple words, a loop means repeating a set of instructions for a given number of inputs. So in this tutorial, we will briefly understand all the loops in Python Programming Language with the help of examples which will help you the easiest way to understand.

Types of Loops in Python Programming Language

In Python Programming, there are 3 types of loops that handle looping requirements. All three types of loops are similar in their own way and they all provide similar functions. They are stated below:-

1. For Loop
2. While Loop
3. Nested Loop

We will understand all the loops statements one by one briefly.

1. For Loop

The Loops which are used for Sequential traversal are known as For Loop. The syntax of For Loop in Python Programming language is similar to the syntax of all other languages. For loop has the easiest syntax and it is the most commonly used in Python Programming Language. Given below is the syntax of For Loop in Python:-

Example of For Loop:-

1. Using range function

We will understand the use of for loop using range function with the help of an example.

From the above code, you can see that we had used for loop with range function and we know that our range function runs from 0 to n-1 terms. So it has printed from 0 to 4 instead of 0 to 5.

2 . Using for loop in a list

We will understand the use of for loop with the help of lists.

In the above code we had used list in for loop and we will get all the elements of the list as output in separate lines respectively.

3 . Using For Loop in String

We will understand the use of for loop with the help of a string.

As it is visible from the above code, we can see that all the elements of the string are printed one by one in separate lines respectively.

While Loop

The loop which can execute a given set of statements as long as the given condition is true is known as While Loop in Python Programming language. But when the condition is false then the line immediately after the loop in the program is executed. The syntax of While Loop is also simple but it provides a better way of looping as it is used in most of the cases where there are comparisons. Let's understand the syntax of While loop in Python Programming language:-

Example of While Loop:-

1. A general example of While Loop

We will understand the use of the While loop with the help of a basic or general example

The above-explained example is the general case of the while loop.

2 . Using While Loop with Break Statement

Let's understand the use of a While loop with a break statement with the help of an example.

As you can see from the above code that we had used a break statement which stops the code after printing 2.

3 . Using While loop with Continue Statement

Let's understand the use of the While loop with the continue statement with the help of an example.

We had used the continue statement in the above code and we can see that our code will execute and will run infinite times as it is in the loop.

Nested Loops

The function of nested loops is similar to the function of nested If- Else statements and in simple words, it means that loop inside a loop. We can use nested for loops and nested while loops. In simpler words, we can use both For Loop and While Loop together in a single program. There is no syntax in Nested Loops as they are comprised of both For loop and While loop.

1. Nested For Loop

We will understand the use of Nested For Loop with the help of an example

From the above code, we can see that we had used two for loops and we can easily see from the output that each f_name is printed with each l_name. We can also use nested For loops to print several different patterns.

2 . Nested While Loops

We will understand the use of Nested While Loop with the help of an example

From the above code, it is clearly visible that we had used while loops which is a nested loop and it will perform the same functions which are similar to the functions of nested For loop, and will give us the output in the same way as nested for loop.

Thanks for Reading. Hope you liked it. Subscribe to our newsletter so that you will get notified of our new posts.

NOTE:- The awesome artwork used in this article was created by Farrúh Tillaev

CREDIT FOR THIS GREAT ARTICLE => Khush Mehndiratta

HAPPY LEARNING!!!

DON'T FORGET TO FOLLOW AND SUBSCRIBE FOR MY NEWSLETTER TO RECEIVE MY FUTURE POSTS

A file can be handled in two ways i.e. Binary(b) and Text(t). A file in Python is also saved with the extension of .txt.

Open() Function

So the first function of file handling is open() and this function will return a file object. There is one important point that you also have to close a file once opened. A file is opened using f.open() and closed using f.close() . This open() function takes two parameters:-

1. filename

2. mode

There are a total of 4 members to open a file in python:-

1. "r" = Read - Opens a file for reading.

2. "w" = Write - Opens a file for Writing.

3. "a" = Append - Opens a file for Appending.

4. "r+" = Read and Write - Opens a file for Reading and Writing.

The syntax for opening a file:-

Opening a file in reading mode:

The above-given syntax is for opening files in reading mode and also the file will be opened in text mode as a file is opened by default in the same mode.

Reading a file on a server

Let's consider a file named file1.txt saved in the same folder as python

To read the above file we will use open() to open the file and read() to read the file.

To read lines in python files we use a function known as readlines() but it will read only a single line.

If you want to read more lines then you have to add more readline() functions. For eg- if you want to read 3 lines then you have to use the readline() function thrice.

Writing in a File

"a" = will append at the end of the line

"w" = will overwrite the content

Append the content

Now we will take an example where we will append the file:-

As you can see that the data has been added at the end of file1.

Now the data from file1 has been removed and the date of file1 has been updated.

Delete a File

In python, you can delete a file using the remove command. Now we will remove the file named file1.txt every python file is removed using import of os module.

Python Directories

Each file in python contains a directory. The os module in python helps in creating, removing, and changing directories.

Syntax of Python Directories:-

Now we will create a test directory in a current directory:-

chdir() method

To change a current directory we use chdir() method. Generally, it takes an argument, which is the name of the directory which we want as our current directory.

rmdir() method

To delete a directory we use the rmdir() method which is passed as an argument in the method

Exception in Python

In the Python programming language, when a script encounters a situation which it cannot cope up with, then it raises an exception. An exception is a Python object which represents an error in the program. There are several exception methods in python:-

1. Exception - Used for all exceptions

2. StopIteration - Occurs when the next() method does not point to any object

3. StandardError - Base class for all built-in exceptions

4. ZeroDivisionError - Raised when division or modulo by zero takes place for all numeric types.

5. FloatingPointError - Raised when any floating-point calculation fails

6. KeyError - Raised when a specific key is not found in the directory

7. SyntaxError - Raised when there is an error in syntax

8. IndentationError - Raised when indentation is not done properly

9. ValueError - Raised when arguments contain invalid values

10. RuntimeError - Raised when a generated error does not fall into any category.

There are several more errors in Python.

Exception Handling

To handle exceptions in python we use try: except. If you found something suspicious in your code which may raise an exception then you can defend your program by placing the suspicious code in a try: block. After that add an except statement, followed by a block of code that will handle the problem easily.

The syntax for Try Except:-

User-Defined Exception

Python is a language that allows you to create your exceptions by deriving some classes from the built-in exceptions. Now we will create an exception using Runtime Error. This is very useful when we need to display more accurate information when an exception is caught.

In the try block, the user-defined exception is raised and after that, it is caught in the except block. The variable e is used to create an instance of the class Network error.

I hope that you had easily understood the concept of files in python. You can visit my youtube channel for more help regarding this topic.

Thanks for reading. Hope you liked it. Many more to come in the future.

Note:- The amazing article used in this post is designed by Victor Korchuk

Buy me a coffee