DEV Community: Marina LABS

Develop yourself to build Web UIs: Part Two: Art of styling the web🎨

Marina LABS — Mon, 26 Aug 2024 17:53:00 +0000

CSS, short for Cascading Style Sheet🎨, dictates how an html should look.

From the previous article on HTML, we knew that the html file will be parsed and Document Object Model will be created. In a similar fashion, CSS file will be parsed and a CSSOM📜 will be created. Alongside DOM, CSSOM will be applied to create a render tree, which forms the layout. Once the layout has been formed, the stylings like the display of elements as specified and then the colors that are to be applied will be decided and rendered in the web page.

Applying CSS: Inlining, Embedding and Linking

There are several ways to apply CSS to an HTML document:

Inline Styles🎯: Directly within the HTML element using the style attribute. This approach is rarely used due to its lack of reusability and separation of concerns
Internal Styles🏡: Within a <style> tag inside the
of your HTML document. This method improves performance as no additional server request is needed to fetch the styles, but it’s less scalable for larger projects.
External Stylesheets🔗: Using a separate .css file linked in the <head> section. This is the most scalable approach, allowing for reuse of styles across multiple pages and easier maintenance.

<!-- inline styling -->
<h1 style="color: white;">Welcome to My Website</h1>

<!-- internal styling -->
<head>
  <style>
    body {
      background-color: lightblue;
    }
    h1 {
      color: navy;
    }
  </style>
</head>

<!-- external stylesheet -->
<head>
  <link rel="stylesheet" href="styles.css">
</head>

While specifying inside the style tag improves performance since there will be no server call made to fetch the styles, it also proves to be redundant in case of complex projects since the css will be confined to the html document📩 and can’t be used in other documents.

On the other hand, using link element to link the style sheets might seem like a solution but might be an overkill🗡 when working on smaller projects or test cases. Still, it offers scalability, and reduced redundancy.

Genius🧠 is not just applying everything, it is about knowing which🕶 to apply and when⌚ to apply

CSS Syntax and Selectors

CSS is structured around selectors that target HTML elements, and properties that apply styles to those elements. Here’s a simple example:

body {
  background-color: lightblue;
}
h1 {
  color: navy;
}

Element Selectors: Target all instances of a specific HTML element.

h1 {
  color: white;
}

Class Selectors: Target elements with a specific class, prefixed with a ..

<p class="className">Text</p>
<a class="className">Link</a>

.className {
  color: white;
}

ID Selectors: Target a single element with a specific ID, prefixed with a #.

<p id="idName">Text</p>

#idName {
  color: white;
}

Notice that for class selectors we need . as prefix and for id we need # as prefix.

Key CSS Concepts and Properties

Before diving into advanced topics, let’s explore some essential CSS properties:

Width & Height: Set the dimensions📐 of an element.
Viewport: The visible🔎 area of a web page on a user’s screen.
Flexbox: A layout model that allows elements to align and distribute space within a container.
Grid: A 2D layout system that enables complex designs with rows and columns.

We will kick off our journey into writing CSS by starting with the enigma😵 that has proved tough even for pragmatic programmers👨‍💻 — Centering a div 😈

div, section {
  display: flex;
  justify-content: center;
  align-items: center;
}

This code centers any child elements within the div or section.

Similarly,

div, section {
  background: linear-gradient(to bottom right, red, blue);
  border: 1px solid black;
  height: 100vh;
  text-align: center;
  border-radius: 5px;
  gap: 15px;
  margin: 20px;
  padding: 10px;
  font-family: Arial, sans-serif;
  font-size: 10px;
  font-weight: 100;
}

In this code:

Background: Sets a gradient background.
Border: Defines the element’s border.
Margin: Adds space outside the element.
Padding: Adds space inside the element.
Font: Customizes the text appearance.

Others are semantic and their name does justice to their function.

CSS In Action: Building a Travel Website

There is no greater fun than creating🛠 something from scratch by yourself.

Don’t feel intimidated by the sheer number of prerequisites required to apply css — it only gets easier once we start.

Oftentimes, at work, software developers wont be designing the website. Dedicated designers🖼, who understand the features of the product, requirements of the users💻 and their behavior, will be designing the website and software developers will need to replicate that.

So, we will find a template from google and try and replicate that.

Head out to the google🌐 and search for “Travel Website Templates” and you can find many of the contemporary designs and once you have chosen something like the one in the image, we can start building.

Start by creating two files: index.html and index.css. Here’s the basic structure:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Travel Site</title>
    <link rel="stylesheet" href="index.css" />
  </head>
  <body>
  </body>
</html>

* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

body {
  font-family: Arial, sans-serif;
  line-height: 1.6;
  background-color: #4d85a2;
  color: #333;
  padding: 20px;
  height: 100vh;
}

Now we can see the result once we start the index.html file in the browser. If you don’t see the changes, refresh the browser tab to see it.

Now, we will start building on top of this, we will create a main container which will hold the image as background, and texts on top of it to achieve the UI.

Write the following code in the body tag.

<div id="main_container"></div>

#main_container {
  background-image: linear-gradient(to bottom right, grey, black)
  background-repeat: no-repeat;
  background-size: cover;
  background-position: center;
  height: 100%;
  border: 1px solid red;
}

Notice, that for background-image attribute, the value should be provided as url(file name) and background-repeat is set to no-repeat and size is set to cover. As for now, we have set the image to a color to visualize.

This ensures that the provided image from the url is set to not repeat and appear only once and appear to the full extent(background-size) unlike only to the dimensions of the image itself. The cover value dictates the image to appear to the container fully. The border has been applied to make it visually teaching on how much height that element is occupying.

Now after applying the image, it should be visible like,

Notice that the image is repeating because we haven’t set background-repeat to no-repeat.

Now we will create a nav bar🧭 that sticks to the top of main container and a centered div to contain information and a button.

Oftentimes, you, as a developer would need to use code that others have written and leverage from that. In this website, we would need to use some icons from other libraries in order to delegate some of the diligent work needed to build that.

I have integrated font-awesome icons in the index.html file by

<head>
  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css"/>
</head>

This ensures that the css written for font-awesome can be extended to my html file without me writing much code.

Now in the body, add the following code,

You will notice certain new terms like keyframes, animations, transition etc.
I will explain them soon, but first lets take a look at the output.

The above picture is the output of the code with borders so as to make it easy to visualize the containers height and width.

The below picture is the finalized output after removing the borders.

Now to the ambiguous code,

:hover — You can see this for page title. This “:” dictates the css to listen for the user actions like hover, focus, etc and then apply css when that action occurs.
Transition — This specifies an animation effect causing motion of the elements as specified like translate, rotate in specified axes, the time that should be taken to complete the effect and the type of effect like ease-in, ease-out, etc.
rgba — This specifies the color alongside the opacity for that color. Notice the black transparent background for the content area? This transparency came because rgba was set to color and 0.7.
animation — Same as transition but only that it can happen even without user interactions. But in here we applied only with user interaction. Other differences include animations can be set to have intermediary steps like on completion of 25% of time, an effect can happen, and same on 50% and 75%, but for transition, only 0% and 100% (start and end) can be specified.
keyframe — These are the tools that are required to set the intermediary steps. Any name can be given including the existing transition names, for which the specified transitions will be applied.

Since without video it is tough to show the animation, you can try hovering your mouse over the Discover Now button to see it pop up.

Outro

You’ve now taken your first steps into the world of CSS. From centering a div to building a basic travel website, you’ve gained hands-on experience with some of the core concepts that will serve as the foundation for more advanced techniques.

The next milestones💎 could include diving into frameworks like Bootstrap or SASS, or moving on to JavaScript and React while simultaneously learning CSS by applying on the go — the limits are endless.

Remember, CSS is a vast and powerful language. With continuous practice and exploration, you can unlock endless possibilities for creative and responsive web designs.

Stay tuned for the next article where we will dive into JavaScript, integrating it with the HTML and CSS skills you’ve just acquired.

This article is written by Anantha Krishnan, a professional with experience in both IT and Mechanical Engineering. With a background in full stack development and a passion for mechanical and electrical systems, Anantha Krishnan is now focused on creating educational content to help beginners in fields of his expertise.

Develop yourself to build Web UIs: Part 1 : Understanding HTML

Marina LABS — Fri, 16 Aug 2024 06:19:59 +0000

Web Development is one of the most in-demand skills today. It involves creating user-friendly and engaging websites that can be accessed via a browser. The first step in becoming a web developer is understanding HTML.

HTML (Hyper Text Markup Language) is the backbone of any web page. It’s the standard language used to structure a webpage, determining how content is displayed in browser. While the appearance of a page is decided by CSS (Cascading Style Sheets) and its functionality by JS (Javascript), HTML is responsible for the fundamental skeleton or structure.

Before diving in this part of the course, it’s important to understand famous and recurring jargons that will be used in your journey. These will help you understand the concepts as we progress (and also make it easy for the author to explain things ;-) ).

Understanding the Jargons

Programming Language: A set of instructions written in a specific syntax (way of a programming language) that a computer can execute. Remember the computer understands only binary code (either 1 or 0), now, in order to make the computer understand the logic and also to find a trade-off, we (humans), have created a programming language such that it is easy for us to code and also for the computer to understand it.
Compiler: A tool that translates code written in a programming language into machine language that a computer can understand and execute.
Syntax: The rules that define the structure of a programming language. Think of it as the way words are arranged in a sentence to make sense.
Comments: Notes within the code that explain what certain parts of the code do. Comments help other developers (or your future self) understand the logic behind your code.
DOM (Document Object Model): The DOM is a tree-like representation of the HTML document. Every tag in your HTML becomes a node in this tree. For example, if your HTML has a <body> tag with a <p> (paragraph) inside it, the browser creates a body node with a paragraph node as its child.
Children: You will understand this as you progress. Elements nested within another element. For example, in HTML, a paragraph tag (<p>) within a div tag (<div>) would be considered a child of the div.
Block-level element: You will be introduced to this jargon as you progress. This term usually describes the feature of the element that it will be taking the full available width.

Firing up with HTML

HTML stands for Hyper Text Markup Language

Hyper Text: Refers to the ability of HTML to link different documents together.
Markup Language: Uses tags to annotate text, defining how it should be displayed in a browser.

Here’s the basic structure of an HTML document:

<!DOCTYPE html>
<html>
  <head>
    <title>HTML Tutorial</title>
  </head>
  <body>
    <p>Hello, world!</p>
  </body>
</html>

Tags: In HTML, tags are used to define elements. Tags are enclosed in angle brackets, like <html> or <p>.
Elements: Consist of an opening tag and a closing tag, which may contain content. For example, <p>Hello, world!</p> is a paragraph element.

HTML Document Structure

Every HTML document follows a basic structure:

<!DOCTYPE html>: Declares the document type and version of HTML.
<html></html>: The root element that encloses all other HTML elements.
<head></head>: Contains meta-information about the document, such as the title and links to stylesheets.
<title></title>: Sets the title of the webpage, displayed in the browser's title bar or tab.
<meta>: Provides metadata about the HTML document, such as character set, author, and viewport settings. It's a self-closing tag.
<style></style>: Embeds CSS code to style the HTML elements.
<script></script>: Embeds JavaScript code for adding interactivity to the webpage.
<body></body>: Encloses the content that will be visible to users on the webpage.

Commonly Used HTML Elements

Here are some basic HTML elements you’ll use frequently:

<p></p>: Defines a paragraph.
<div></div>: A block-level element used to group other elements together.
<span></span>: An inline element used to group text for styling purposes.
<header></header>: Represents the introductory content or navigational links of a section.
<h1></h1> to <h6></h6>: Headings, with <h1> being the highest level and <h6> the lowest.
<br>: Inserts a line break (self-closing tag — meaning there is no need to close the tag).
<form></form>: Used to create an HTML form for user input.
<input>: Creates an input field, typically used within a form.
<select></select>: Creates a dropdown list.
<label></label>: Associates a text label with a form element.
<table></table>: Defines a table.
<tr></tr>: Defines a row in a table.
<td></td>: Defines a cell in a table row.
<th></th>: Defines a header cell in a table row.
<ul></ul>: Defines an unordered (bulleted) list.
<ol></ol>: Defines an ordered (numbered) list.
<li></li>: Defines a list item.

Creating Your First HTML File

To create an HTML file, you can use any text editor, such as Notepad or VS Code. Here’s a simple example:

Open your text editor and type the following code:

<!DOCTYPE html>
<html>
<head>
  <title>HTML Tutorial</title>
</head>
<body>
  <h1>Example Number 1</h1>
  <p>Hello, world!</p>
</body>
</html>

Save the file with a .html extension (e.g., index.html)
Open the file in your web browser to see your first HTML webpage in action!
To inspect your code, press Ctrl + Shift + C in Google Chrome to open the Developer Tools and explore the DOM structure.
Go to the network tab in the Developer Tools and refresh your browser tab.

You can find that there is a request in the name that you have saved as in this picture.

In the response tab, you will find the code that you have written as in the following picture

Now, what happened is that, once you opened the file you have saved as html, the computer began running the file in browser. The browser wanted something to show, so it made a request call to the file from which it was launched. The file gave the browser your code and that was found in the response section. Since it was a html file, the browser begins reading the HTML code from the top to the bottom. This process is known as parsing. During parsing, the browser encounters different HTML tags (like <html>, <head>, <body>, etc.) and starts to build a structure called DOM based on these tags. As the browser builds the DOM, it simultaneously renders the content on your screen.

Creating a Table

Let’s take a step further by creating a simple table in HTML:

Open the same HTML file and add the following code inside the <body> tag:

<p>Table Example</p>
<table>
  <tr>
    <th>Name</th>
    <th>Power</th>
    <th>Is Kurama Present</th>
  </tr>
  <tr>
    <td>Naruto</td>
    <td>Rasengan</td>
    <td>Yes</td>
  </tr>
  <tr>
    <td>Sasuke</td>
    <td>Sharingan</td>
    <td>No</td>
  </tr>
</table>

Save the file and refresh your browser to see the table displayed.

Notice the heading is being rendered by paragraph tag. Alternatively, you can also use <caption> tag, which will center the heading of the table. Experiment with the caption tag and refresh to see the changes.

Note that <caption> tag should only be used immediately after the <table> opening tag.

You’ve now successfully created a basic table in HTML. Feel free to experiment with additional rows and columns to get more comfortable with HTML syntax.

Conclusion

Congratulations on completing your first steps into web development with HTML! The key to mastering HTML is practice. Experiment with different elements, create your own webpages, and don’t be afraid to make mistakes — every error is a learning opportunity.

Remember, this is just the beginning. As you continue to build on this foundation, you’ll soon be able to create more complex and dynamic websites. Let’s make the web a better place, one line of code at a time.

This article is written by Anantha Krishnan, a professional with experience in both IT and Mechanical Engineering. With a background in full stack development and a passion for mechanical and electrical systems, Anantha Krishnan is now focused on creating educational content to help beginners in fields of his expertise.