In web design, CSS (Cascading Style Sheets) gives you unprecedented control over how elements appear on a page. Two of the most fundamental tools within CSS are the ‘display’ and ‘position’ properties. Understanding how they work is a major step towards building the layouts you envision. Let’s dive in!

The CSS ‘display’ Property

The ‘display’ property dictates the basic way an element interacts with the content around it. Think of it as the element’s personality within the flow of the page. Here are the most common values you’ll encounter:

• block: Block-level elements take up a full line and stack vertically, like paragraphs in a book. Common examples include <div>, <h1>, and <p>.
• inline: Inline elements behave as part of the text flow, only using as much width as they need. Examples are <span> and <a> (links).
• inline-block: This value combines aspects of both ‘block’ and ‘inline’, allowing you to give inline elements some block-like features (like setting width and height).
• none: This completely hides the element, as if it wasn’t on the page at all.

The CSS ‘position’ Property

Where ‘display’ handles the fundamental behavior, ‘position’ deals with fine-tuning element placement. Key options include:

• static: The default. Things simply go where the normal flow of the webpage puts them.
• relative: The element is adjusted relative to its normal position. Crucially, other elements aren’t rearranged to make space for it.
• absolute: The element is taken out of the normal flow altogether. It’s positioned relative to its closest ancestor that also has positioning set (or the browser window if none exist).
• fixed: A ‘fixed’ element stays put in a specific location within the viewport, even when you scroll the page.
• sticky: A clever hybrid. It behaves like ‘relative’ until you scroll past a certain point, then it sticks as if it were ‘fixed’.

How They Work in Practice

Let’s see these in action:

• Overlapping Elements: Using ‘position: absolute’ (or ‘relative’) along with z-index is your key to layering elements over one another.
• Navigation Bars: Many navigation menus are ‘position: fixed’ to the top of the screen so they’re always accessible, even on long pages.
• Modal Dialogs (Popups): These are often ‘position: fixed’ and centered within the viewport.

Points to Remember

• The Containing Block: When using ‘absolute’ or ‘fixed’, an element is positioned concerning the closest parent with a ‘position’ setting (not ‘static’). If there isn’t one, it looks to the edges of the browser window.
• Browser Compatibility: Always be mindful that old browsers might have the odd quirk with how they handle positioning.
• Accessibility: Don’t change the ‘display’ type of elements in a way that confuses screen readers and other assistive technologies.

See it in Action

The best way to get a feel for ‘display’ and ‘position’ is to experiment! Visit popular websites, right-click on elements, and choose “Inspect” to see their CSS and play around with changing it.

Wrapping Up

Mastering ‘display’ and ‘position’ grants you immense power in how you can structure your web pages. Keep experimenting, and if you ever get stuck, there are always excellent resources online like the MDN Web Docs for reference.

Unoptimized images can dramatically slow down page loads, frustrating users. Let’s explore key image optimization strategies for crafting beautiful and lightning-fast websites.

1. File Format Fundamentals

Understanding file formats is step one:

• JPEG (JPG): The go-to for photographs and complex gradients. Offers good compression, but quality can degrade with excessive compression.
• PNG: Preserves transparency for logos or where backgrounds need to show through. Can lead to larger file sizes, especially for complex images.
• WebP: Google’s modern solution, offering superior compression than JPEG and PNG while maintaining quality. Not yet universally supported across all browsers.
• SVG: Ideal for logos, icons, and illustrations due to infinite scalability without quality loss. Since they’re vector-based, they’re often quite small in file size.

2. The Power of Compression

Image compression is non-negotiable. It’s about finding the sweet spot between maintaining image quality and minimizing file size:

• Online tools: Offer easy solutions (TinyPNG, Squoosh, etc.). Be mindful of potential slight quality reductions.
• Plugins: CMS-specific plugins automatically handle compression and are a convenient option if you use WordPress or similar platforms.
• Advanced control: Developers can leverage command-line tools (ImageMagick or imagemin) for fine-tuned optimization.

3. Image Sizing: The Key to Efficiency

Display images at their intended size. Avoid the pitfall of uploading huge images that the browser then needs to scale down. Match the image dimensions to how it will be displayed on the page.

4. Lazy Loading: Your Performance Savior

Lazy loading delays the loading of images below the fold until a user scrolls toward them. This technique prioritizes the most important content for an initial fast page load, and then loads the rest of the imagery as needed.

5. Responsive Images for a Seamless Experience

The <picture> and <img srcset> HTML tags provide a robust method for handling images across different devices. Your website can offer the browser a set of image versions to select from based on viewport size and screen resolution.

6. Alt Text: Not Just a Nice-to-Have

Take the time for descriptive alt attributes:

• Accessibility: Ensure your site is inclusive by providing text descriptions for images read by assistive technologies.
• SEO: Search engines factor in alt text to understand images. Write informative descriptions with relevant keywords.

7. CDNs for Worldwide Delivery

A Content Delivery Network (CDN) can significantly enhance load times for sites with global audiences. CDNs geographically distribute your images; users are served images from the closest server for faster delivery.

Additional Considerations

• HTTP/2 and Image Sprites: HTTP/2 can load multiple images simultaneously, potentially negating some advantages of older techniques like image spriting (combining multiple small images into one).
• New Formats: Keep an eye on emerging formats like AVIF, offering even better compression potential.

Let’s Wrap Up

Image optimization doesn’t have to be a complex process. By following these guidelines, you’ll be well on your way to visually appealing websites optimized for performance – resulting in happy users and potentially better search visibility.

Web development is continuously evolving, with new tools and technologies emerging to streamline processes, enhance performance, and secure web applications. Amidst this technological evolution, Netlify stands out as a pivotal platform offering developers robust features to deploy websites efficiently. This post aims to delve into Netlify’s practical aspects, shedding light on how it can be leveraged to optimize web development workflows rather than selling its virtues.

The Role of Netlify Web Hosting in Modern Web Development

Netlify has carved a niche for itself in the web development world by offering an integrated platform that simplifies deployment and hosting of websites. Here’s how it fits into the modern web development ecosystem:

• Git-based Workflow Integration: Automates the deployment process by linking directly to your Git repositories, enabling a seamless transition from code commits to live updates.
• Serverless Functions: Facilitates the creation of dynamic, event-driven functionalities without the overhead of server management.
• Global Content Delivery: Leverages a worldwide CDN to ensure fast loading times, improving user experience and website performance.

Netlify Pricing Tiers

Practical Applications and Optimization

Streamlining Deployment

Netlify automates the deployment process, directly connecting with Git repositories to deploy updates as soon as changes are pushed. This automation reduces manual oversight and potential human errors, ensuring a smoother workflow. For developers, this means more time focusing on coding and less on the intricacies of deployment logistics.

Enhancing Web Performance

Performance optimization is crucial for any web project. Netlify’s global CDN and intelligent caching mechanisms significantly reduce load times, directly impacting user engagement and SEO rankings. Developers can leverage these features to ensure their sites meet the highest web performance standards.

Secure and Scalable Infrastructure

Security and scalability are built into the fabric of Netlify, with automatic HTTPS, DDoS protection, and scalable infrastructure. These features provide a secure environment for web applications to grow, adapting to increased traffic and evolving security threats without requiring manual intervention.

Real-World Use Cases

Understanding how others have successfully utilized Netlify can provide valuable insights:

• Portfolio Websites: Many developers use Netlify to host their portfolio sites, taking advantage of its easy deployment and superior performance features.
• E-commerce Platforms: Netlify’s serverless functions and secure environment make it a choice for e-commerce sites, facilitating fast, secure transactions.
• Blogs and Content Sites: Content creators leverage Netlify’s CDN for faster content delivery, ensuring readers worldwide access information quickly.

Tips for Maximizing Efficiency with Netlify

• Automate Everything: Use Netlify’s build hooks and webhooks to automate your workflow, from testing to deployment.
• Utilize Serverless Functions: Experiment with serverless functions for adding dynamic content or creating API endpoints without managing a server.
• Monitor and Optimize: Take advantage of Netlify Analytics to monitor your site’s performance and identify areas for optimization.

Conclusion

Netlify provides a comprehensive platform for deploying and hosting web applications, emphasizing efficiency, performance, and security. By incorporating Netlify into your web development workflow, you can leverage its automated processes, global CDN, and serverless functions to enhance your projects. Whether you’re building a personal blog, a portfolio, or a full-scale e-commerce site, understanding and utilizing Netlify’s features can significantly improve your development process and the overall performance of your web applications.

In the bustling world of web development, efficiency and error reduction are key. That’s where Create React App (CRA) and TypeScript come into play. CRA offers a streamlined way to kickstart React projects, while TypeScript brings the power of type safety, making your code not only more robust but also easier to understand. This guide will walk you through integrating TypeScript with your React project using CRA, enhancing your development process with type safety and other benefits TypeScript has to offer.

Why TypeScript?

TypeScript has rapidly gained popularity among developers for several reasons:

• Type Safety: By defining types for your variables and functions, TypeScript ensures that you use your code as intended, catching errors early in the development process.
• Easier Debugging: With compile-time error checking, TypeScript helps identify potential issues before they become problematic, reducing runtime errors.
• Enhanced Developer Experience: TypeScript’s intelligent code completion and suggestions based on types significantly improve the coding experience, making development faster and more enjoyable.

Getting Started with Create React App and TypeScript

Creating a new React project with TypeScript is straightforward thanks to CRA. Here’s how you can get started:

1. Creating a New Project: Open your terminal and run the command npx create-react-app my-app --template typescript. This command creates a new React project named my-app with TypeScript setup out of the box.
2. Project Structure: Once the setup completes, you’ll have a project folder with a predefined structure. Key directories include src for your source files and public for public assets like your HTML file.
3. Initial Setup: Ensure you have Node.js and npm/yarn installed on your system to work with CRA and TypeScript.

Configuring TypeScript with Create React App

CRA automatically configures TypeScript for you, but it’s helpful to understand some of the configurations:

• tsconfig.json: This file contains TypeScript compiler options. CRA sets sensible defaults, but you may adjust these settings for your project needs.
• Custom Configurations: Sometimes, you might want to customize the TypeScript configuration, such as setting up path aliases for more manageable imports. You can do this by editing the tsconfig.json file.

Developing React Components with TypeScript

TypeScript enhances React component development in several ways. Here are examples for both functional and class components:

• Functional Components: Use the React.FC type to define functional components with typed props.
  tsx

  interface MyComponentProps {
title: string;
content: string;
}const MyComponent: React.FC<MyComponentProps> = ({ title, content }) => (
  <div>
  <h1>{title}</h1>
  <p>{content}</p>
  </div>
  );

• Class Components: For class components, type both props and state for full type checking.
  tsx

  interface MyComponentProps {
title: string;
}interface MyComponentState {
  content: string;
  }

  class MyComponent extends React.Component<MyComponentProps, MyComponentState> {
  state: MyComponentState = {
  content: “Initial content”,
  };

  render() {
  return (
  <div>
  <h1>{this.props.title}</h1>
  <p>{this.state.content}</p>
  </div>
  );
  }
  }

Integrating Third-Party Libraries with TypeScript in a CRA Project

Working with third-party libraries is a common scenario, and TypeScript has you covered with DefinitelyTyped:

• Using @types for Type Definitions: Install type definitions from DefinitelyTyped using npm or yarn (e.g., npm install @types/react-router-dom).
• Handling Libraries without @types: For libraries without available type definitions, you can declare custom types or use any as a temporary workaround.

Debugging and Testing

TypeScript also improves the debugging and testing experience:

• Debugging: Use source maps to debug your TypeScript code directly in browsers or IDEs like Visual Studio Code.
• Testing: Configure your testing framework, such as Jest, to work with TypeScript for type-safe tests.

Deployment and Best Practices

Before deploying your project, consider these best practices:

• Preparing for Deployment: Run npm run build to create a production-ready build of your project.
• Best Practices: Keep your tsconfig.json clean, regularly update your TypeScript and type definitions, and organize your project files for scalability.

Conclusion

Integrating TypeScript with Create React App not only enhances your development experience but also leads to more reliable and maintainable code. By following this guide, you’re well on your way to leveraging the full potential of TypeScript in your React projects. Experiment, explore, and don’t be afraid to dive deeper into TypeScript’s features to elevate your web development journey.

The ability of a website to seamlessly adapt to a multitude of screen sizes and devices is a hallmark of modern web development. Responsive design, powered by CSS media queries, is the key to achieving this essential flexibility.

Understanding the Fundamentals of Media Queries

• Definition: CSS media queries enable you to apply different styles based on device characteristics like screen size, orientation, and resolution.
• Syntax: A media query includes a media type and at least one media feature expression:

@media screen and (min-width: 768px) {
  /* Styles for tablets and larger screens */
}

• Targeting Beyond Screen Width: Leverage other media features:
  • orientation: landscape/portrait
  • print
  • resolution

Building Responsive Layouts

• Breakpoints as Content Guides: Choose breakpoints based on where the layout visually breaks down, rather than relying solely on generic device sizes.
• Layout Transformation: Here’s how to use media queries in tandem with flexbox or grid:

.container {
  display: flex;
  flex-wrap: wrap;
}
.item {
   flex-basis: 100%;  /* Stack items vertically on small screens */
}

@media screen and (min-width: 992px) {
  .item {
    flex-basis: 33.33%; /* Arrange items in three columns */
  }
}

Optimizing Images & Content

• Image Responsiveness:
  • Employ srcset and sizes attributes for image optimization across different resolutions.
  • Consider the picture element for art direction scenarios.
• Fluid Typography: Use units like em or rem for font sizes, and viewport units (vh, vw) for elements like line-height to create dynamic scaling with screen size.
• Content-First: Adapt content order and visibility using media queries to ensure readability and a logical user experience on all devices.

Testing & Refinement

• Rigorous Testing:
  • Dev tools are helpful, but testing on real devices is critical for identifying device-specific quirks.
  • Pay close attention to image loading performance and overall layout fluidity across device screens.
• Accessibility: Ensure your responsive design choices enhance accessibility, not hinder it.

Conclusion

Mastering CSS media queries is fundamental to creating websites that deliver a positive user experience, regardless of the device being used. Stay committed to refining your implementation as new devices and web standards emerge.

Are you ready to take your web styling skills to the next level? If you’re familiar with the basics of CSS, SCSS (Sassy CSS) is a powerful tool that will supercharge your workflow. SCSS lets you write cleaner, more organized, and more adaptable stylesheets, making your web development projects a breeze!

What is SCSS and Why Should You Care?

Click here for my favorite SCSS online courses

• SCSS in a nutshell: SCSS is a CSS preprocessor. Think of it as CSS with extra superpowers. You write code in .scss files, and it gets compiled into regular CSS that browsers understand.
• Benefits of SCSS:
  • Organization: SCSS allows you to nest CSS rules, leading to more readable code that reflects your website’s structure.
  • Reusability: Variables and mixins let you define styles once and reuse them throughout your project.
  • Dynamic Style: Functions and operators let you do things like lighten/darken colors on the fly.
  • Maintainability: SCSS makes large projects easier to manage and update.

Setting Up Your SCSS Environment – Tutorial

We have a great article on how to set up SCSS with more detail here.

1. Choose Your Weapon: We’ll use Node-sass, a popular compiler. Firstly, make sure you have Node.js and npm installed (https://nodejs.org/).
2. Install: Open your terminal and type: npm install node-sass
3. Code Editor Integration: Explore extensions for your favorite code editor (like Visual Studio Code) that can automatically compile your SCSS on save.
4. Quick Experimentation: For quick tests, try an online compiler like Sassmeister (https://www.sassmeister.com/).

SCSS Fundamentals

• Nesting:

nav {
  ul {
    list-style: none;
  }
  li { 
    display: inline-block;
  }
}

See how much cleaner this is compared to regular CSS!

• Variables:

  SCSS

  $primary-color: #007bff;
  $font-stack: 'Arial', sans-serif;
  
  body {
    background-color: $primary-color;
    font-family: $font-stack;
  }
  

  Change the value of $primary-color once, and it updates everywhere!

• Mixins:

  SCSS

  @mixin border-radius($radius) {
      border-radius: $radius;
  }
  
  button {
    @include border-radius(5px);
  }
  

  Mixins save you from writing the same CSS repeatedly.

• Functions & Operators

  SCSS

  button {
    background-color: lighten($primary-color, 10%); 
  } 
  

  Calculate styles directly within your code!

Linking SCSS to HTML

• After you’ve compiled your SCSS into a .css file, you link it to your HTML like any other stylesheet:
  HTML

  <link rel="stylesheet" type="text/css" href="style.css"> 
  

Mini Project: Styling a Navigation Bar

Let’s use our new knowledge to create a simple navigation bar (see code examples on your blog platform). This will reinforce the concepts in a practical way.

Next Steps & Resources

• Official Docs: The SCSS documentation is your best friend: https://sass-lang.com/
• Advanced Tutorials: Explore more complex SCSS techniques as you get comfortable.

Memory games are a fantastic way to practice your React skills while building something fun! In this tutorial, we’ll guide you through creating your own memory game from scratch using React.

Prerequisites

• Familiarity with basic React concepts (components, props, state, JSX).
• Some CSS knowledge for styling (we’ll provide basic examples).

Project Setup

1. Create a new React project:

   Bash

   npx create-react-app memory-game
   

2. Structure your project:

   src/
     components/
       Card.js
       GameBoard.js
     App.js
     styles.css
   

Building the Game

Click here for my favorite React reference book 

1. Data and Card Component

• Card Data Structure (in Card.js)

  JavaScript

  const Card = ({ id, image, isFlipped, isMatched, handleClick }) => {
    return (
      <div 
        className={`card ${isFlipped ? 'flipped' : ''} ${isMatched ? 'matched' : ''}`}
        onClick={() => handleClick(id)}
      >
        <div className="front">{/* Placeholder for a question mark or back image */}</div> 
        <div className="back">
          <img src={image} alt="Card Content" /> 
        </div>
      </div>
    );
  };
  
  export default Card;
  

• Explanation:

  • Each card has id, image, and flags for isFlipped and isMatched.
  • We use CSS classes for styling the different states of the card.

2. Game Board and Rendering

// In GameBoard.js
import React, { useState, useEffect } from 'react';
import Card from './Card';
import shuffle from 'lodash.shuffle'; // Or your own shuffle function

const GameBoard = () => {
  const [cards, setCards] = useState(shuffleCards()); // We'll define shuffleCards later
  const [flippedCards, setFlippedCards] = useState([]);
  const [matchedCards, setMatchedCards] = useState([]);

  // ... Code for handleClick, checking matches (from previous examples)

  // Function to generate and shuffle card data
  const shuffleCards = () => {
    // ... Add your logic to create card objects with images  
  }

  return (
    <div className="game-board">
      {cards.map((card) => (
        <Card 
          key={card.id} 
          {...card} 
          handleClick={handleClick} 
        />
      ))}
    </div>
  );
};

export default GameBoard;

3. Core Game Logic (Explained in Previous Examples)

• handleClick (prevents invalid clicks, adds card ID to flippedCards)
• useEffect (checks for matches, updates matchedCards, resets flippedCards)

4. Styling (styles.css):

.game-board {
  display: grid;
  grid-template-columns: repeat(4, 1fr); /* Adjust for grid size */
}

.card { 
  /* Add styles for the card container */
}

.flipped {
  /* Styles for when the card is flipped */
}

.matched {
  /* Styles to indicate matched cards */
}

5. Win Condition, Restart, Additional Features (Choose one or two)

Deployment (Briefly mention options)

Conclusion

Congratulations on building your memory game! Try customizing its looks, adding difficulty levels, timers, or other fun features!

In web design, properly presenting images and videos across various different devices and screen sizes can be quite a challenge. This is where the CSS object-fit property becomes a game-changer, allowing developers to control how these elements fit into their containers. Object-fit is your go-to solution if you’re looking to maintain aspect ratios, fill specific areas without distortion, or simply manage how your content is displayed. This post will dive deep into the object-fit property, showcasing how it works through practical examples.

What is Object-Fit?

The object-fit property in CSS dictates how <img> or <video> elements should resize to fit their containers. It offers several strategies for resizing content, such as maintaining the original aspect ratio, filling the designated area, or even clipping content to ensure a perfect fit.

The Syntax

The syntax for object-fit is straightforward:

css

object-fit: value; 

Here, value can be one of the following:

• fill
• contain
• cover
• none
• scale-down

Exploring Object-Fit Values

Let’s explore what each object-fit value signifies and when to use it:

• Fill: Stretches the content to fit the container, possibly distorting the aspect ratio. Ideal when the content’s exact dimensions must match the container’s.
• Contain: Scales the content to fit the container while preserving its aspect ratio. All content is visible, but this may introduce empty space in the container.
• Cover: Ensures the content fully covers the container, maintaining its aspect ratio. Some content might be clipped to achieve this.
• None: Displays the content at its original size, not resizing it to fit in the container.
• Scale-Down: Acts like either none or contain, whichever results in a smaller size, effectively preventing upscaling.

Practical Examples

To illustrate how object-fit can be applied, let’s look at some examples:

Example 1: Using object-fit: cover;

Imagine you have a square container where you want to display an image without distorting its aspect ratio, even if it means clipping some parts of the image.

HTML:

html

<div class=”container”> <img src=”path/to/image.jpg” alt=”Beautiful Landscape”> </div> 

CSS:

css

.container { width: 200px; height: 200px; overflow: hidden; } .container img { width: 100%; height: 100%; object-fit: cover; } 

This setup ensures the image covers the entire container, maintains its aspect ratio, and clips any excess.

Example 2: Ensuring Full Visibility with object-fit: contain;

For situations where you want to ensure the entire image is visible without clipping:

CSS adjustment:

css

.container img { object-fit: contain; } 

Now, the image scales down to fit within the container, ensuring all content is visible, potentially adding empty space around it.

When to Use Object-Fit

Object-fit is incredibly useful in responsive design, where container sizes vary across devices. It helps in:

• Maintaining aspect ratios of images or videos.
• Filling background images without stretching.
• Ensuring visuals look good on devices of all sizes.

Conclusion

The object-fit property is a powerful tool in the CSS toolkit, enabling developers and designers to create visually consistent and appealing websites. By understanding and applying the different values of object-fit, you can ensure that your images and videos always look their best, regardless of the container size or screen resolution.

Experiment with object-fit in your next project and see the difference it makes in your responsive designs. 

Prettier is more than just a code formatter; it’s a path to unified code presentation, easing collaboration across teams and reducing time spent on styling discussions. Supporting a wide array of languages and integrations with most popular editors, Prettier ensures that your code is not only consistent but also adheres to best practices.

Installation and Initial Setup

To get started with Prettier in your project, you’ll first need to install it. If you’re working on a node.js project, you can add Prettier as a development dependency:

bash

npm install –save-dev prettier 

Or, if you prefer using Yarn:

bash

yarn add –dev prettier 

Configuring Prettier for Your Project

Creating a .prettierrc file in your project’s root directory allows you to specify your formatting preferences. Here’s an example configuration that outlines most options you might want to customize:

json

{ “semi”: false, “tabWidth”: 2, “printWidth”: 80, “singleQuote”: true, “trailingComma”: “es5”, “jsxSingleQuote”: true, “bracketSpacing”: true, “jsxBracketSameLine”: false, “arrowParens”: “avoid”, “endOfLine”: “lf” } 

Explanation of Configuration Options

• semi: Whether to add a semicolon at the end of every statement (false means no semicolons).
• tabWidth: Number of spaces per indentation level.
• printWidth: The maximum line length where Prettier will try to wrap the code.
• singleQuote: Use single quotes instead of double quotes where applicable.
• trailingComma: Adds a trailing comma to object and array elements to minimize version control diffs (es5 allows trailing commas in ES5-compatible places).
• jsxSingleQuote: Use single quotes in JSX attributes.
• bracketSpacing: Controls the spacing between brackets in object literals, array brackets, etc.
• jsxBracketSameLine: When true, keeps the closing JSX tag of a multi-line element on the same line as the last prop.
• arrowParens: Controls the printing of parentheses around single-argument arrow function parameters (“avoid” omits the parentheses).
• endOfLine: Enforces a consistent line ending style (lf, crlf, auto).

Integrating Prettier into Your Workflow

To make the most of Prettier, integrate it into your development workflow. Adding a script in your package.json makes it easy to format your codebase consistently:

json

“scripts”: { “format”: “prettier –write .” } 

This script will format all supported files in your project directory. Run it via:

bash

npm run format 

Customizing Prettier for Different Scenarios

Remember, these settings are not one-size-fits-all. Adjust them based on your project’s needs, team agreements, or personal preferences. Prettier’s flexibility means it can adapt to various coding styles and project requirements, making it a powerful tool for maintaining code quality.

Conclusion

Prettier streamlines code formatting, allowing developers to focus on the logic and functionality of their code. By integrating Prettier into your project, you establish a consistent codebase that’s easier to read, maintain, and collaborate on. Experiment with the configurations, integrate them into your development process, and watch as Prettier transforms your coding workflow for the better.