What is Responsive Design?

Responsive Design refers to an approach in web development that makes web pages render well on a variety of devices and screen sizes. With responsive design, a website or web application dynamically adjusts its layout, content, and features to provide an optimal viewing experience across different devices—whether it’s a desktop, tablet, or smartphone.

Responsive web design (RWD) is based on the fluid grid layout concept, where the layout elements are sized relative to the viewport. This ensures that the layout adapts and scales appropriately based on the screen size and resolution. Responsive design uses flexible grids, media queries, and flexible images to ensure that the layout works seamlessly on multiple devices without the need for separate versions of the site.

Key Principles of Responsive Design:

1. Fluid Grid Layout: Instead of fixed-width layouts, responsive design uses percentage-based widths so that content resizes fluidly based on the screen size.
2. Flexible Images: Images and media assets are resized using CSS to prevent them from breaking the layout on smaller screens.
3. Media Queries: Media queries allow designers to apply different styles based on the screen’s characteristics, such as width, height, resolution, and orientation.

With responsive design, developers can create websites that are mobile-friendly, tablet-compatible, and optimized for larger screens without duplicating content for each device.

What Are the Major Use Cases of Responsive Design?

Responsive design is widely used in various scenarios to provide a seamless user experience across devices. Below are some of the major use cases for responsive design:

1. Mobile-Friendly Websites:

• Use Case: As the number of mobile users continues to grow, having a mobile-friendly website is critical. Responsive design ensures that websites look great and function well on both smartphones and tablets.
• Example: An e-commerce website using responsive design will automatically adjust its layout to fit the small screen of a mobile device, providing easy navigation, quick access to product details, and a smooth checkout process.
• Why Responsive Design? Mobile traffic now accounts for a significant portion of all web traffic. Websites that aren’t optimized for mobile devices risk losing visitors and customers. Responsive design solves this problem.

2. Cross-Device Compatibility:

• Use Case: Websites must support a wide range of devices, including smartphones, tablets, desktops, and laptops. Responsive design ensures that websites deliver a consistent experience regardless of device type or screen size.
• Example: A news website that adapts its layout based on the screen size, allowing easy readability and intuitive navigation on both large desktop monitors and small mobile screens.
• Why Responsive Design? With the increasing number of devices and screen resolutions, developers need a single, flexible solution to ensure their website works across platforms without building separate versions.

3. SEO Benefits:

• Use Case: Responsive design can improve a website’s SEO performance. Google prefers mobile-friendly websites because they offer a better user experience and are easier to index.
• Example: A local business website that adapts to both desktop and mobile will rank better in search results for local searches and attract more mobile customers.
• Why Responsive Design? Having a single, responsive URL for all devices makes it easier for search engines to index and rank your site, leading to better search engine optimization (SEO).

4. E-Commerce and Digital Services:

• Use Case: For online stores or service-based websites, responsive design ensures that customers have an optimized experience, whether they’re shopping from a desktop, tablet, or phone.
• Example: A shopping website that provides an optimized mobile experience, offering zoomable images, swiping product carousels, and a clean checkout flow.
• Why Responsive Design? Conversion rates improve when customers can easily browse and make purchases on any device. With responsive design, an online store can cater to mobile users without compromising the desktop experience.

5. Content-heavy Websites:

• Use Case: Websites with a lot of content, like blogs, news websites, and documentation sites, benefit greatly from responsive design because it allows the content to adapt to different screen sizes, improving readability and navigation.
• Example: A blog that automatically adjusts text size, line spacing, and image layout for different devices.
• Why Responsive Design? Content-heavy websites are frequently visited on mobile devices. Responsive design helps ensure that users can easily read, navigate, and interact with content regardless of screen size.

How Responsive Design Works Along with Architecture?

Responsive design works by utilizing a combination of fluid grids, media queries, and flexible images. Below is an explanation of how these components fit together in the architecture of a responsive website:

1. Fluid Grid Layout:

• Instead of using fixed-width layouts with set pixel values, fluid grids use percentages to define the layout’s structure. This allows the layout to scale proportionally with the browser window.
• Example: Instead of setting a column to be 300px wide, a fluid grid sets the column width to 25%, allowing it to resize depending on the screen width.
• How It Works: A responsive grid layout allows elements to adjust their width relative to the screen size, ensuring that content looks good on screens of any size.

2. Media Queries:

• Media queries are the backbone of responsive design. They allow developers to apply different styles based on the device’s width, height, resolution, and orientation.
• Example: The following media query adjusts the layout for devices with a screen width smaller than 600px (typically smartphones):

@media only screen and (max-width: 600px) {
  body {
    font-size: 16px;
  }
  .main-content {
    padding: 10px;
  }
}

• How It Works: When the screen size reaches a certain threshold (e.g., under 600px), the styles defined inside the media query are applied, adjusting the website’s layout for optimal display on smaller screens.

3. Flexible Images:

• Flexible images ensure that images scale appropriately on various devices. This is achieved by using CSS rules like max-width: 100% and height: auto to make images responsive to different screen sizes.
• Example: Instead of using a fixed-width image, a responsive image will automatically adjust its size to fit the screen:

img {
  max-width: 100%;
  height: auto;
}

• How It Works: This rule ensures that images don’t overflow the layout, and instead, they resize themselves according to the width of the parent container, maintaining aspect ratio.

4. Mobile-first Approach:

• Responsive design often follows a mobile-first approach, where styles are initially designed for smaller screens (e.g., smartphones), and then additional styles are added for larger screens (e.g., tablets, desktops).
• Example: The default CSS for small screens is written first, and then media queries are used to add styles for larger screens.
• How It Works: Mobile-first ensures that the website is optimized for the most constrained devices first and then progressively enhanced for devices with more resources.

What Are the Basic Workflow of Responsive Design?

The basic workflow for implementing responsive design involves several key steps to ensure that your website adapts to different devices seamlessly:

1. Plan and Design for Multiple Devices:

• The first step is to understand the range of devices and screen sizes your audience uses. Use analytics tools to determine the most common screen sizes for your users.
• Sketch or wireframe the layout for different devices. Tools like Figma, Sketch, or Adobe XD can help you create responsive designs for various breakpoints (e.g., mobile, tablet, desktop).

2. Start with a Mobile-first Approach:

• Begin designing the website for the smallest screen size first (usually smartphones). Apply styles that work well for these constrained devices, ensuring that the content is readable, navigation is intuitive, and images are optimized.
• Use flexible grids and responsive typography to ensure that the layout scales smoothly.

3. Implement Fluid Grids and Layouts:

• Use percentage-based widths for elements instead of fixed pixel values. This makes the layout flexible, allowing it to expand or contract based on the screen size.
• Ensure that containers, columns, and other layout components adjust dynamically.

4. Use Media Queries to Target Different Devices:

• Once the mobile layout is in place, use media queries to apply different styles for larger screens, such as tablets and desktops.
• For example, you might increase the size of images or change the number of columns on larger screens.

5. Test Responsiveness:

• Test your website on multiple devices or use browser tools to simulate different screen sizes. Ensure that the layout, images, and text adapt properly on each device.
• Browser developer tools (e.g., Chrome DevTools) have built-in functionality to test responsiveness on various screen sizes.

6. Optimize Images and Content:

• Make sure that images are responsive and optimized for various screen sizes to reduce load times. Use modern formats like WebP for smaller file sizes.
• Consider using responsive images with the srcset attribute for different screen resolutions and sizes.

7. Continuous Improvement:

• Responsive design is an ongoing process. Continuously monitor and test how your website performs on different devices, and optimize it for new screen sizes and user behaviors.
• Stay updated with best practices and emerging trends in responsive design.

Step-by-Step Getting Started Guide for Responsive Design

Step 1: Set up Your Development Environment

• Choose a text editor (e.g., VS Code, Sublime Text) or an IDE for writing HTML, CSS, and JavaScript.
• Make sure you have the browser developer tools enabled for easy testing of responsive behavior.

Step 2: Create a Basic HTML Template

• Start with a basic HTML structure, ensuring that you use semantic tags for accessibility and SEO.
• Example:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Responsive Design</title>
</head>
<body>
  <header>
    <h1>Welcome to My Responsive Website</h1>
  </header>
  <main>
    <section>
      <p>This is a simple, responsive design example.</p>
    </section>
  </main>
</body>
</html>

Step 3: Add Basic CSS for Mobile-first Design

• Write basic CSS for mobile devices, ensuring that text is readable and layout works well.
• Example:

body {
  font-family: Arial, sans-serif;
  margin: 0;
  padding: 0;
}
header {
  background-color: #333;
  color: white;
  text-align: center;
  padding: 20px;
}

Step 4: Implement Media Queries

• Add media queries to apply different styles for larger screens.
• Example:

@media only screen and (min-width: 600px) {
  body {
    background-color: #f0f0f0;
  }
  header {
    font-size: 1.5rem;
  }
}

Step 5: Test Responsiveness

• Use browser tools to test how the layout adapts to different screen sizes.
• Refine and adjust layout, fonts, and images based on testing feedback.

What is UIView?

UIView is one of the central components in iOS development and is an essential class in the UIKit framework, responsible for displaying visual content on the screen. Every UI element you see on an iOS app—whether it’s a button, label, text field, or even a custom UI component—is derived from UIView or one of its subclasses.

In simple terms, a UIView is a rectangular area on the screen that can contain visual content and handle user interaction. All visual elements (UI controls, images, animations, and custom views) are rendered inside a UIView. Not only does UIView manage the layout of its own visual components, but it is also responsible for interacting with touch events, gestures, and animations.

Core Concepts of UIView:

1. Rectangular Area: A view is bound within a rectangular area that defines its size and position on the screen.
2. Rendering: It is responsible for drawing its content on the screen, whether that be built-in UI elements (buttons, text fields) or custom graphics.
3. Interaction: Handles user input, including touch gestures (e.g., taps, swipes), making it an integral part of handling user interactions.
4. Layout: It manages the layout of its subviews (child views), which are other UIView objects nested inside it. These subviews can have their own properties and content.
5. Performance: UIView ensures smooth rendering and interaction, especially when used for animations and UI updates.

The UIView class is highly flexible and provides the foundation for building the user interface of iOS apps.

What Are the Major Use Cases of UIView?

UIView is central to any iOS app, used extensively across multiple use cases in app development. Here are some major use cases where UIView plays a pivotal role:

1. Creating User Interface Elements:

• Use Case: Every visual element in an iOS app, such as buttons, labels, text fields, and sliders, is essentially a UIView or a subclass of UIView.
• Example: A login screen with text fields for username and password and a login button is implemented as a UIView with subviews.
• Why UIView? UIView provides a simple way to organize and manage visual elements, ensuring that each element (like a button or image) is properly sized, positioned, and rendered.

2. Managing Complex Layouts:

• Use Case: UIView handles layout and view hierarchy, making it possible to build complex UI layouts by nesting views inside one another.
• Example: A tab bar controller or a navigation controller uses multiple UIView elements arranged in a hierarchical structure to create the app’s interface.
• Why UIView? It’s easy to structure and organize views hierarchically using UIView and handle layout dynamically using Auto Layout.

3. Handling User Interaction:

• Use Case: UIView is responsible for handling touch events such as tap, drag, pinch, and swipe gestures, enabling user interaction with the UI.
• Example: In a photo gallery app, tapping on an image view opens the photo in a new screen, or swiping left/right switches between photos.
• Why UIView? UIView can respond to user input directly through methods like touchesBegan, touchesMoved, or by using gesture recognizers.

4. Implementing Custom Views:

• Use Case: Developers can subclass UIView to create custom views that are not part of the standard UIKit controls, such as custom charts, animated elements, or special effects.
• Example: A progress bar that visually fills up as a download progresses, or a custom drawing canvas where users can draw with their fingers.
• Why UIView? Subclassing UIView allows for fine control over the drawing process and interaction, making it possible to create unique and reusable UI components.

5. Animation and Transition Effects:

• Use Case: UIView enables developers to implement animations like fades, slides, or transforms, which enhance the user experience by providing smooth transitions.
• Example: Fading in a UILabel with a message or animating a view from one position to another.
• Why UIView? UIView has built-in support for animations, allowing developers to animate view properties like alpha, position, rotation, and scaling.

6. Responsive and Adaptive Layouts:

• Use Case: UIView works with Auto Layout to create responsive layouts that adapt to different screen sizes and orientations.
• Example: A multicolumn layout for an iPad that switches to a single-column layout on an iPhone, adjusting based on the screen size.
• Why UIView? Auto Layout makes it easy to define relationships between views that automatically adjust based on screen size, orientation, and other dynamic factors.

How UIView Works Along with Architecture?

The architecture of a typical iOS app relies heavily on UIView to create a structured layout, handle user interactions, and ensure proper rendering of visual components. Let’s explore how UIView interacts with various layers in the architecture of an iOS app:

1. UIKit Framework:

• UIView is a central class within the UIKit framework, which provides all the necessary tools to create and manage the user interface in iOS applications.
• UIKit also includes other essential components, such as UIViewController, UIControl, and UIStackView, that work together with UIView to build complete user interfaces.
• UIViewController: This class manages the lifecycle of a screen (view) and serves as the bridge between the user interface and application logic. A UIViewController typically manages a view hierarchy (the collection of UIView instances that make up the screen).

2. View Hierarchy:

• UIView supports a view hierarchy, where views are nested inside each other. A parent UIView can contain subviews (child views), which can, in turn, contain other subviews.
• Example: In a complex screen layout, a parent UIView may contain multiple subviews such as buttons, labels, image views, and other components.
• The frame of each view determines its size and position within its parent view.

3. Auto Layout:

• Auto Layout is a system in iOS that works alongside UIView to automatically adjust the layout of views based on constraints.
• Auto Layout uses constraints to define how views should be positioned relative to each other, ensuring that the user interface is adaptable to different screen sizes and orientations.

4. Handling Touch Events and Gesture Recognition:

• Event Handling: UIView manages user touch events and interaction. For example, when the user taps or swipes on the screen, UIView captures these events and forwards them to the appropriate view.
• Gesture Recognizers: In addition to basic touch event handling, UIView can also be used with gesture recognizers (such as UITapGestureRecognizer, UISwipeGestureRecognizer) to detect more complex interactions like taps, pinches, and swipes.

5. Rendering and Drawing:

• When a UIView needs to update or redraw itself (such as when the content changes), it calls the drawRect(_:) method (if overridden in a custom view).
• This method allows you to draw custom content using Core Graphics or other graphic libraries. For example, you might override drawRect(_:) to create a custom shape, line, or even an image inside a UIView.

What Are the Basic Workflow of UIView?

The basic workflow of using UIView in an iOS application involves several steps from initialization, layout, event handling, and rendering. Below is a simplified workflow:

1.View Initialization:

• Views are typically created either programmatically in code or through Interface Builder (using storyboards or XIB files).
• Example: Create a simple UILabel programmatically and add it to a parent view:

let label = UILabel()
label.text = "Hello, World!"
parentView.addSubview(label)

2. Setting Layout:

• The layout process is triggered when the view is added to a superview or when layout constraints are defined using Auto Layout.
• Example: Set constraints to ensure a UILabel is centered within its parent view:

label.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    label.centerXAnchor.constraint(equalTo: parentView.centerXAnchor),
    label.centerYAnchor.constraint(equalTo: parentView.centerYAnchor)
])

3. Handling User Interaction:

• Once a view is set up, it listens for user interactions, such as taps, swipes, or other gestures. You can handle these interactions by overriding touch event methods or using gesture recognizers.
• Example: Add a gesture recognizer to a UIView to detect taps:

let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))
parentView.addGestureRecognizer(tapGesture)

4. Rendering and Redrawing:

• When a view’s content or layout changes, it may need to be redrawn. You can trigger a redraw by calling setNeedsDisplay() or setNeedsLayout().
• Example: Update a custom drawing in a UIView:

override func draw(_ rect: CGRect) {
    super.draw(rect)
    // Drawing code goes here
}

5. Animation and Transition:

• UIView supports animations, allowing views to smoothly transition between states, such as fading in or moving across the screen.
• Example: Animate the opacity of a view:

UIView.animate(withDuration: 1.0) {
    label.alpha = 0.0
}

Step-by-Step Getting Started Guide for UIView

Here is a detailed guide on how to get started with UIView in an iOS project:

Step 1: Create a New iOS Project

• Open Xcode, select Create a new Xcode project, and choose Single View App.
• Name your project and set the appropriate settings.

Step 2: Add a UIView Programmatically

• Create a new UIView inside your ViewController class. Add it to the main view:

let customView = UIView()
customView.backgroundColor = .red
view.addSubview(customView)

Step 3: Add Layout Constraints

• Set constraints for the UIView to position it within the parent view. Use Auto Layout to make sure it adjusts to different screen sizes.

customView.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    customView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    customView.centerYAnchor.constraint(equalTo: view.centerYAnchor),
    customView.widthAnchor.constraint(equalToConstant: 200),
    customView.heightAnchor.constraint(equalToConstant: 200)
])

Step 4: Handle Touch Events

• Add a gesture recognizer to handle user taps:

let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))
customView.addGestureRecognizer(tapGesture)

Step 5: Implement the Gesture Handler

• Implement the function to respond to the tap gesture:

@objc func handleTap() {
    print("UIView tapped!")
}

Step 6: Test and Run

• Run the application on the iOS simulator or a device to see your custom UIView in action. Tap on the view to trigger the event.

Introduction

In the world of web development and design, layout refers to the arrangement and organization of visual elements on a page, screen, or interface. It determines how content, including text, images, buttons, and other UI components, are positioned and structured to ensure both usability and aesthetics. A well-designed layout is crucial for creating a positive user experience (UX) and can significantly impact how users interact with a website or application.

This guide will explore what layout is, its major use cases, how layout works, the architecture of layout design, the basic workflow, and a step-by-step guide on how to get started with layout development. Whether you’re building a website, mobile app, or dashboard, understanding layout design principles is key to creating interfaces that are both visually appealing and user-friendly.

What is Layout?

A layout in design is the way in which visual elements are arranged and organized within a given space. In the context of web development and UI design, layout refers to how elements are positioned, aligned, and distributed across a page or screen. It encompasses everything from the grid system, typography, spacing, and responsive behaviors to the interaction patterns between components.

A layout helps to:

• Guide User Attention: Directs the user’s eye and provides a clear path for navigation.
• Provide Structure: Organizes content in a way that makes sense to the user, ensuring accessibility and clarity.
• Maintain Consistency: Consistent layouts across pages and screens help users easily recognize and understand interfaces.

Key Components of Layout:

1. Containers: Blocks that hold content such as headers, footers, sidebars, and content areas.
2. Grids: An underlying structure for organizing elements systematically, often used for responsive design.
3. Spacing: The margins, padding, and gutter spaces that define the distance between elements.
4. Alignment: Ensuring that elements align horizontally or vertically to maintain harmony and readability.
5. Typography and Visual Hierarchy: The arrangement of text and images to prioritize and emphasize content.

Major Use Cases of Layout

Layout plays a significant role in nearly every type of application or website, affecting everything from user engagement to usability. Below are some of the major use cases of layout in different contexts:

1. Responsive Web Design

Layouts are crucial for responsive web design, where content must adapt to different screen sizes (desktops, tablets, mobile phones). The goal is to ensure that a website or application looks and functions optimally across devices.

• Use Case Example: A responsive grid layout that shifts and rearranges content depending on the screen size, ensuring a seamless experience on all devices.

2. Mobile App Design

Mobile applications use layout to ensure that content is displayed clearly on smaller screens. Layout strategies like flexbox, grid, and stacking help design mobile apps that offer a user-friendly experience.

• Use Case Example: A bottom navigation bar layout on a mobile app ensures ease of navigation by providing important actions and views at the bottom of the screen, making them easily accessible.

3. Dashboard Design

Dashboards use layout to arrange complex data and metrics in an easy-to-read, digestible manner. A good dashboard layout will prioritize key information and provide interactive components such as charts, tables, and filters.

• Use Case Example: A financial dashboard layout that organizes widgets like balance sheets, transaction lists, and charts for key performance indicators (KPIs) in a grid format.

4. E-commerce Websites

In e-commerce, layout is used to arrange products, categories, filters, and CTAs (Call-to-Actions) in a way that encourages browsing and purchasing. The visual hierarchy plays a key role in highlighting promotions and important information.

• Use Case Example: An e-commerce layout that uses a grid system to display product listings with images, descriptions, and prices, while promoting sales with a sticky navigation bar at the top.

5. Single Page Applications (SPA)

In SPAs, layout adapts to show different types of content based on user interaction. The layout must ensure that the transition between views is smooth and intuitive.

• Use Case Example: A portfolio website that uses a card-based layout to show different project categories with smooth transitions between each section when clicked.

How Layout Works: Architecture

Understanding how layout works is crucial for designing flexible and effective web pages. The architecture of layout typically follows a few key principles that guide the structure and flexibility of elements on the screen.

1. Grid System

A grid system is a set of intersecting horizontal and vertical lines that divide a page into columns and rows. It is commonly used to organize content in a consistent and symmetrical manner. Grid systems, such as CSS Grid or Bootstrap’s grid layout, allow designers to create flexible, responsive layouts.

• Example: A 12-column grid system is commonly used in modern web design, where the layout is divided into 12 equal columns. The designer can control how many columns a component takes up, providing flexibility and responsiveness.

2. Flexbox

Flexbox is a layout model designed to lay out items within a container. It allows for dynamic positioning, aligning items along the horizontal or vertical axes, and distributing space between items automatically.

• Example: A flex container can display cards or buttons in a row with equal spacing, regardless of the content size.

.container {
  display: flex;
  justify-content: space-between;
}

3. Positioning (Static, Relative, Absolute, Fixed)

CSS positioning is used to control the position of elements within the layout. The four main types of positioning are:

• Static: Default positioning, where elements flow in the document.
• Relative: Positions an element relative to its normal position.
• Absolute: Positions an element relative to its closest positioned ancestor.
• Fixed: Fixes an element in place on the page even when scrolling.

4. Responsive Design

Layout must adapt to different screen sizes and orientations. Responsive design is often implemented using media queries, which allow the layout to change based on device characteristics like width, height, and screen resolution.

• Example: Using media queries to switch from a multi-column layout on desktop to a stacked single column on mobile devices:

@media screen and (max-width: 768px) {
  .container {
    display: block;
  }
}

Basic Workflow of Layout

The basic workflow of creating and implementing a layout in a web application typically follows these steps:

1. Plan the Layout: Define the structure of the page, including the header, footer, sidebars, content area, and how elements will interact across different screen sizes.
2. Choose a Layout System: Decide whether to use a grid system, flexbox, or CSS layout modules. This step defines the fundamental approach to how the layout will adjust and be aligned.
3. Design the UI: Implement the visual elements using HTML and CSS. Define the containers, elements, and spacing using the layout strategy chosen in step 2.
4. Test Responsiveness: Use media queries to ensure that the layout adapts properly to different screen sizes (mobile, tablet, desktop).
5. Refine: Tweak the layout for consistency, visual appeal, and functionality. Ensure that the layout enhances usability and achieves the desired user experience (UX).

Step-by-Step Getting Started Guide for Layout

Step 1: Understand the Structure of Your Page

Determine the basic elements of the page you are designing. For example, a common layout might have:

• Header: Contains navigation and branding.
• Sidebar: Optional; used for additional navigation or filters.
• Main Content Area: Where the primary content or features are displayed.
• Footer: Contains links to terms, privacy policy, and additional navigation.

Step 2: Choose a Layout Model

Choose between layout models like flexbox, grid, or a custom layout based on the complexity of your design:

• For simple layouts, flexbox is often sufficient.
• For more complex grid-based layouts, CSS Grid provides a more flexible solution.

Step 3: Build the Layout with HTML and CSS

Using HTML and CSS, start by creating the basic structure of the page using divs or section tags. For example:

<header>
  <h1>My Website</h1>
  <nav>Navigation Menu</nav>
</header>
<main>
  <section class="sidebar">Sidebar Content</section>
  <section class="content">Main Content</section>
</main>
<footer>Footer Information</footer>

Step 4: Add CSS for Layout

Define how the page content will be structured with CSS:

body {
  display: flex;
  flex-direction: column;
}

header, footer {
  background-color: #f8f8f8;
  padding: 20px;
}

main {
  display: flex;
  justify-content: space-between;
}

.sidebar {
  width: 20%;
  background-color: #e0e0e0;
  padding: 10px;
}

.content {
  width: 75%;
  padding: 10px;
}

Step 5: Test for Responsiveness

Use media queries to ensure that your layout adjusts based on screen size:

@media screen and (max-width: 768px) {
  main {
    flex-direction: column;
  }

  .sidebar {
    width: 100%;
  }

  .content {
    width: 100%;
  }
}

Step 6: Refine and Optimize

Ensure that your layout is visually appealing, consistent, and accessible. Check that elements are aligned correctly, and test the layout across various screen sizes.