Webmasters Gallery

What website design techniques made the most impact in 2023? We’ve got a look back at the best trends of the year.

In the ever-expanding universe of data administration, organizations grapple with a crucial decision—Cloud Archiving versus On-Premise Archiving—a choice that takes center stage in their quest for compliance excellence. 

In order to choose well, we need a detailed investigation that carefully looks at the pros and cons of each option. This involves understanding how different choices affect compliance in the complex world of digital data storage.

Pros of Cloud Archiving

One of the primary advantages of Cloud Archiving lies in its scalability and accessibility. 

Organizations can leverage the vast storage capabilities of cloud providers, adapting to the fluctuating volume of data seamlessly. 

Additionally, the cloud facilitates remote access, enabling users to retrieve archived data from anywhere with an internet connection. This accessibility enhances collaboration and simplifies compliance audits, allowing for swift data retrieval.

Cons of Cloud Archiving

However, concerns over data security and privacy persist with Cloud Archiving. 

Entrusting sensitive information to third-party cloud providers raises questions about unauthorized access and potential breaches. While reputable cloud service providers implement robust security measures, the perceived loss of control over data security remains a lingering reservation for some organizations, especially those operating in highly regulated industries.

Pros of On-Premise Archiving

On the flip side, On-Premise Archiving offers organizations greater control over their data. With the infrastructure maintained on-site, companies can implement customized security protocols and safeguards tailored to their specific needs. This level of control is particularly appealing for organizations handling highly sensitive data, where regulatory compliance demands stringent security measures.

Cons of On-Premise Archiving

However, the initial setup costs and ongoing maintenance of On-Premise Archiving can be substantial. The need for physical hardware dedicated IT personnel, and routine maintenance contributes to higher operational expenses. Additionally, the scalability of On-Premise Archiving may pose challenges as organizations expand, requiring continuous investment in infrastructure to accommodate growing data volumes.

The Role of Archiving Software

A pivotal consideration in the Cloud vs On-Premise Archiving debate is the utilization of archiving software. 

This specialized software plays a crucial role in streamlining the archiving process, automating data retention policies, and ensuring efficient retrieval during audits. The choice of archiving software can significantly impact the overall effectiveness of an organization’s archival strategy. 

Cloud Archiving often integrates seamlessly with this software provided by cloud service vendors, offering a user-friendly and cohesive solution. 

On the other hand, On-Premise Archiving demands careful selection and maintenance of archiving software to maximize efficiency and compliance.

Hybrid Solutions

Recognizing the nuanced needs of organizations, hybrid solutions that combine elements of both Cloud and On-Premise Archiving have gained prominence in recent years. 

This approach allows organizations to retain sensitive data on-premise while utilizing the scalability and accessibility of the cloud for less critical information. Hybrid solutions offer a middle ground, catering to diverse compliance requirements and striking a balance between security and flexibility.

Compliance Considerations

Several key considerations come to the forefront when evaluating archiving solutions for compliance. 

Regulatory bodies often impose specific requirements regarding data retention periods, encryption standards, and audit trails. Cloud Archiving, with its remote accessibility and seamless scalability, can facilitate compliance by enabling organizations to adapt to evolving regulatory landscapes efficiently. On the other hand, On-Premise Archiving provides a level of control that can be advantageous for organizations navigating stringent compliance frameworks.

Strategic Decision-Making for Tomorrow

In conclusion, the choice between Cloud and On-Premise Archiving transcends mere data storage preferences—it’s a strategic decision that shapes an organization’s compliance posture. As technology evolves and regulatory landscapes shift, the adaptability of chosen archiving solutions becomes paramount. The dynamic interplay between Cloud Archiving’s accessibility and On-Premise Archiving’s control underscores the need for organizations to align their archival strategies with their unique compliance requirements, ensuring a resilient and future-ready data management approach.

Continuous Evaluation for Optimal Compliance

Archiving is constantly changing, so an organization’s approach to compliance should keep up.

Beyond the initial choice of Cloud or On-Premise Archiving, a commitment to continuous evaluation, adaptation, and integration of cutting-edge archiving software ensures that compliance remains a checkbox and a proactive and evolving aspect of an organization’s data management strategy. 

Fostering a culture of agility and embracing emerging technologies, organizations navigate compliance intricacies with resilience and foresight.

Making the right choice

In the ever-evolving landscape of data management and compliance, the choice between Cloud Archiving and On-Premise Archiving is a strategic decision that demands careful consideration of an organization’s unique needs and regulatory obligations. 

While Cloud Archiving offers unparalleled scalability and accessibility, organizations must address concerns related to data security. On-premise archiving provides enhanced control over data security but requires significant upfront investments.

Conclusion

Regardless of the chosen approach, archiving software serves as the linchpin in the efficient data management process and compliance adherence. As organizations navigate the complexities of data archiving, integrating robust archiving software ensures compliance becomes an integral part of the archival process. 

Whether in the cloud or on-premise, the synergy between archiving solutions and compliance requirements is pivotal for organizations seeking to safeguard their data while meeting regulatory standards in an increasingly digital landscape.

Featured image by Pixabay

The post Cloud Archiving vs On-Premise Archiving: Pros and Cons for Compliance appeared first on noupe.

In the last year, much has been written about how artificial intelligence (AI) is poised to upend virtually every industry you can name. Some see it as the “silver bullet” they’ve been waiting for on their quest to work smarter, not harder. Others fear that it may be a technological innovation that we ultimately cannot control – one that will eventually replace human jobs with automation to the detriment of us all.

While it’s difficult to say how AI will play out in the long-term, in the near future, artificial intelligence should be seen for what it really is: a productivity adrenalin shot in the best possible way. This is particularly true in terms of real estate investing, which is a notoriously time-consuming affair.

Think about everything one must devote themselves to for a successful real estate career. They need a deep understanding of the market – including not just where it is but where it has been and where it might be going. They need to wade through countless property listings until they find the right ones that meet their unique investment strategies. The list goes on and on.

Artificial intelligence can help with all of this, freeing up valuable time for real estate entrepreneurs so that they can focus on more important matters. In fact, AI is already empowering those entrepreneurs right now in a wide range of different ways, all of which are worth a closer look.

Actionable Information at Your Fingertips

One of the major ways that AI in real estate empowers young entrepreneurs has to do with the wealth of information it gives them access to in real-time.

Think about the sheer amount of human error you could be exposed to when performing something as seemingly straightforward as market analysis. Not only do you have to make sure your data comes from high-quality sources, but you also have to interpret it correctly. You need to be in a position to act on it, and you need to make informed choices when doing so.

AI algorithms can analyze massive volumes of data – far more than a human ever could. Not only will they be able to quickly verify trends and patterns in terms of things like property values, but they’ll do so with greater accuracy than even a team of people likely could.

You’re left with instant insight, illuminating the path you need to take to accomplish your investment goals. Is it impossible to get to this point without AI in real estate? Absolutely not – but it’s far easier and more efficient to lean into what technology has to offer.

Incredible Time-Savings

Another major way that AI in real estate empowers entrepreneurs is due to the sheer amount of time it can help someone save.

Think about how inherently complicated a traditional real estate transaction can be. Now, double that amount of effort within the context of wholesale real estate. This is because you’re now working with a buyer and a seller, as opposed to just one or the other.

If you already have a seller and know about the property in question, AI in real estate can help you finely target your marketing to get it in front of the people who are most likely to be interested as quickly as possible. In a situation that already has razor-thin profit margins, artificial intelligence can save as much time – and thus money – as possible. This helps to not only create that perfect situation that is beneficial to all parties, but it does so in a more cost-effective manner than ever. This preserves as much money as possible to go directly into your own pocket as profit.

The Property Management Advantages

There are those investors out there who are in it for the long game. They’re not just trying to buy a property to flip. They want to own, rent, and manage it to create passive income for themselves or boost their portfolio. This is another area where AI in real estate can absolutely come in handy.

Using sophisticated artificial intelligence-driven systems, it’s never been easier to monitor the conditions of a property. You can even see things on a unit-by-unit basis if you’re talking about a multi-family home like an apartment. You can predict maintenance requirements to fix small problems now before they become larger, more expensive ones later. You can take steps to reduce energy use and related costs, creating more profit for yourself. You can even allow AI to help with customer service to create a better tenant experience – something that will keep people satisfied, vacancies low, and your return on investment ultimately as high as it can go.

AI: Another Tool in Your Toolbox

In the end, it’s important to remember that in real estate, in particular, the one thing you’ll never be able to automate is a relationship. If you’re a seller, you need to find the right buyer and get them to trust you. If you’re a buyer, you need a seller. Wholesale real estate professionals need to forge two relationships to create a single positive outcome for everyone. All the innovative real estate software in the world will never change that.

But by freeing up their valuable time, artificial intelligence is ultimately empowering seasoned real estate entrepreneurs to do precisely that. They don’t have to spend countless hours pouring over historical data to determine which trends are on the rise and which are about to fizzle out. They don’t have to sink hours into examining properties until they find the best match for what they’re trying to accomplish. AI can do this with a fraction of the time and effort it used to require, all while generating results that are more accurate than a human is likely capable of.

This doesn’t mean real estate investment gets easier or that you can run your career on autopilot. It simply means that you’ve been gifted with more hours in a day to focus on what matters most: creating those mutually beneficial relationships. That’s an exciting position to be in regardless of how long you’ve been investing, and it’s something that was only possible thanks to the advent of artificial intelligence as we know it.

Featured Image by Austin Distel on Unsplash

The post 3 Ways AI is Empowering Real Estate Entrepreneurs   appeared first on noupe.

We’ve reached that time of year when all marketing is on a singular theme: snow, presents, and turkey (or nut roast, if that’s your preference).

You know what’s perhaps the “cheapest” way to make a slider of images, right? You set up a container, drop a bunch of inline image elements in it, then set overflow-x: auto on it, allowing us to swipe through them. The same idea applies nicely to a group of cards, too.

But we’ll go deeper than scroll snapping. The thing with sliders is that it can be difficult to instruct them on where to “snap.” For example, what if we want to configure the slider in such a way that images always snap at the left (or inline-start) edge when swiping right to left?

But that’s not even the “tricky” part we’re looking at. Say we are working within an existing page layout where the main container of the page has a set amount of padding applied to it. In this case, the slider should always begin at the inline starting edge of the inside of the container, and when scrolling, each image should snap to the edge rather than scroll past it.

Simply drop the slider in the layout container, right? It’s not as straightforward as you might think. If you notice in the illustrations, the slider is outside the page’s main container because we need it to go full-width. We do that in order to allow the images to scroll fully edge-to-edge and overflow the main body.

Our challenge is to make sure the slider snaps into place consistent with the page layout’s spacing, indicated by the dashed blue lines in the drawings. The green area represents the page container’s padding, and we want images to snap right at the blue line.

The Basic Layout

Let’s start with some baseline HTML that includes a header and footer, each with an inner .container element that’s used for the page’s layout. Our slider will sit in between the header and footer but lack the same inner .container that applies padding and width to it so that the images scroll the full width of the page.

<header>
  <div class="container">
    <!-- some contained header with some nav items -->
  </div>
</header>
<main>
  <section class="slider">
    <!-- our slider -->
  </section>
  <section class="body-text">
    <div class="container">
      <!-- some contained text -->
    </div>
  </section>
</main>
<footer>
  <div class="container">
    <!-- a contained footer -->
  </div>
</footer>

Creating The Container

In contrast to the emphasis I’ve put on scroll snapping for this demo, the real power in creating the slider does not actually start with scroll snapping. The trick to create something like this starts with the layout .container elements inside the header and footer. We’ll set up a few CSS variables and configure the .container’s properties, such as its width and padding.

The following bit of CSS defines a set of variables that are used to control the maximum width and padding of a container element. The @media rules are used to apply different values to these properties depending on the viewport’s width.

:root {
  --c-max-width: 100%;
  --c-padding: 10px;

  @media screen and (min-width: 768px) {
    --c-max-width: 800px;
    --c-padding: 12px;
  }
  @media screen and (min-width: 1000px) {
    --c-max-width: 940px;
    --c-padding: 24px;
  }
  @media screen and (min-width: 1200px) {
    --c-max-width: 1200px;
    --c-padding: 40px;
  }
}

The first couple of lines of the :root element’s ruleset define two CSS custom properties: --c-max-width and --c-padding. These properties are used to control the layout .container’s maximum width and padding.

Next up, we have our @media rules. These apply different values to the –-c-max-width and --c-padding properties depending on the screen size. For example, the first @media rule updates the value of --c-max-width from 100% to 800px, as well as the --c-padding from 10px to 12px when the screen width is at least 768px.

Those are the variables. We then set up the style rules for the container, which we’ve creatively named .container, and apply those variables to it. The .container’s maximum width and inline padding are assigned to the also creatively-named -c-max-width and --c-padding variables. This opens up our container’s variables at a root level so that they can easily be accessed by other elements when we need them.

I am using pixels in these examples because I want this tutorial to be about the actual technique instead of using different sizing units. Also, please note that I will be using CSS nesting for the demos, as it is supported in every major browser at the time I’m writing this.

The Scroll-Snapping

Let’s work on the scroll-snapping part of this slider. The first thing we’re going to do is update the HTML with the images. Remember that this slider is outside of the .container (we’ll take care of that later).

<header>
  <!-- .container -->
</header

<section class="slider">
  <div>
    <img src="..." alt="">
  </div>
  <div>
    <img src="..." alt="">
  </div>
  <div>
    <img src="..." alt="">
  </div>
  <!-- etc. -->
</section>

<footer>
  <!-- .container -->
</footer>

Now we have a a group of divs that are direct children of the .slider. And those, in turn, each contain one image element. With this intact, it’s time for us to style this as an actual slider. Flexbox is an efficient way to change the display behavior of the .slider’s divs so that they flow in the inline direction rather than stacking vertically as they naturally would as block-level elements. Using Flexbox also gives us access to the gap property to space things out a bit.

.slider {
  display: flex;
  gap: 24px;
}

Now we can let the images overflow the .slider in the horizontal, or inline, direction:

.slider {
  display: flex;
  gap: 24px;
  overflow-x: auto;
}

Before we apply scroll snapping, we ought to configure the divs so that the images are equally sized. A slider is so much better to use when the images are visually consistent rather than having a mix of portrait and landscape orientations, creating a jagged flow. We can use the flex property on the child divs, which is shorthand for the flex-shrink, flex-grow, and flex-basis properties:

.slider {
  display: flex;
  gap: 24px;
  overflow-x: auto;

  > * {
    flex: 0 0 300px;
  }
}

This way, the divs are only as big as the content they contain and will not exceed a width of 300px. But! In order to contain the images in the space, we will set them to take up the full 100% width of the divs, slap an aspect-ratio on them to maintain proportions, then use the object-fit property to to cover the div’s dimensions.

.slider {
  display: flex;
  gap: 24px;
  overflow-x: auto;

  > * {
    flex: 0 0 300px;
  }

  & img {
    aspect-ratio: 3 / 4;
    object-fit: cover;
    width: 100%;
  }
}

With this in place, we can now turn to scroll snapping:

.slider {
  display: flex;
  gap: 24px;
  overflow-x: auto;
  scroll-snap-type: x mandatory;

  > * {
    flex: 0 0 300px;
    scroll-snap-align: start;
  }

  /*
}

Here’s what’s up:

• We’re using the scroll-snap-type property on the .slider container to initialize scroll snapping in the horizizontal (x) direction. The mandatory keyword means we’re forcing the slider to snap on items in the container instead of allowing it to scroll at will and land wherever it wants.
• We’re using the scroll-snap-align property on the divs to set the snapping on the item’s start-ing edge (or “right” edge in a typical horizontal left-to-right writing mode).

Good so far? Here’s what we’ve made up to this point:

See the Pen Cheap Slider, Scroll Snapped [forked] by Geoff Graham.

Calculating The Offset Size

Now that we have all of our pieces in place, it’s time to create the exact snapping layout we want. We already know what the maximum width of the page’s layout .container is because we set it up to change at different breakpoints with the variables we registered at the beginning. In other words, the .container’s width will never exceed the value of --c-max-width. We also know the container always has a padding equal to the value of --c-padding.

Again, our slider is outside of the .container, and yet, we want the scroll-snapped images to align with those values for a balanced page layout. Let’s create a new CSS variable, but this time scoped to the .slider and set it up to calculate the space between the viewport and the inside of the .container element.

.slider {
  --offset-width: calc(((100% - (min(var(--c-max-width), 100%) + (var(--c-padding) * 2))) / 2) + (var(--c-padding) * 2)
  );
}

That is a lot of math! First, we’re calculating the minimum value of either the .container element’s max-width or 100%, whichever is smaller, then increasing this minimum value with padding on the .slider. This result is then subtracted from 100%. From this, we get the total amount of space that is available to offset either side of the .slider to align with the layout .container.

We then divide this number by 2 to get the offset width for each specific side. And finally, we add the .container’s inline padding to the offset width so that the .slider is offset from the inside edges of the container rather than the outside edges. In the demo, I have used the universal selector (*) and its pseudos to measure the box-sizing of all elements by the border-box so that we are working inside the .slider’s borders rather than outside of it.

*, *::before, *::after {
  box-sizing: border-box;
}

Some Minor Cleanup

If you think that our code is becoming a bit too chaotic, we can certainly improve it a bit. When I run into these situations, I sometimes like to organize things into multiple custom properties just for easy reading. For example, we could combine the inline paddings that are scoped to the :root and update the slider’s --offset-width variable with a calc() function that’s a bit easier on the eyes.

:root {
  /* previous container custom properties */

   --c-padding-inline: calc(var(--c-padding) * 2);
}

.slider {
  --offset-width: calc(((100% - (min(var(--c-max-width), 100%) + var(--c-padding-inline))) / 2) + var(--c-padding-inline));

  /* etc. */
}

That’s a smidge better, right?

Aligning The Slider With The Page Layout

We have a fully-functioning scroll scroll-snapping container at this point! The last thing for us to do is apply padding to it that aligns with the layout .container. As a reminder, the challenge is for us to respect the page layout’s padding even though the .slider is a full-width element outside of that container.

This means we need to apply our newly-created --offset-width variable to the .slider. We’ve already scoped the variable to the .slider, so all we really need is to apply it to the right properties. Here’s what that looks like:

.slider {
  --offset-width: calc(
    ((100% - (min(var(--c-max-width), 100%) + (var(--c-padding) * 2))) / 2) + (var(--c-padding) * 2)
  );

  padding-inline: var(--offset-width);
  scroll-padding-inline-start: var(--offset-width);

  /* etc. */
  }

The padding-inline and scroll-padding-inline-start properties are used to offset the slider from the left and right sides of its container and to ensure that the slider is always fully visible when the user scrolls.

• padding-inline
  This sets spacing inside the .slider’s inline edges. A nice thing about using this logical property instead of a physical property is that we can apply the padding in both directions in one fell swoop, as there is no physical property shorthand that combines padding-left and padding-right. This way, the .slider’s internal inline spacing matches that of the .container in a single declaration.
• scroll-padding-inline-start
  This sets the scroll padding at the start of the slider’s inline dimension. This scroll padding is equal to the amount of space that is added to the left (i.e., inline start) side of the .slider’s content during the scroll.

Now that the padding-inline and scroll-padding-inline-start properties are both set to the value of the --offset-width variable, we can ensure that the slider is perfectly aligned with the start of our container and snaps with the start of that container when the user scrolls.

We could take all of this a step further by setting the gap of our slider items to be the same as our padding gap. We’re really creating a flexible system here:

.slider {
  --gap: var(--c-padding);
  gap: var(--gap);
}

Personally, I would scope this into a new custom property of the slider itself, but it’s more of a personal preference. The full demo can be found on CodePen. I added a toggle in the demo so you can easily track the maximum width and paddings while resizing.

See the Pen Full width scroll snap that snaps to the container [forked] by utilitybend.

But we don’t have to stop here! We can do all sorts of calculations with our custom properties. Maybe instead of adding a fixed width to the .slider’s flex children, we want to always display three images at a time inside of the container:

.slider {
  --gap: var(--c-padding);
  --flex-width: calc((100% - var(--gap) * 2) / 3);

  /* Previous scroll snap code */

  > * {
    flex: 0 0 var(--flex-width);
    scroll-snap-align: start;
  }
}

That --flex-width custom property takes 100% of the container the slider is in and subtracts it by two times the --gap. And, because we want three items in view at a time, we divide that result by 3.

See the Pen Updated scroll container with 3 items fitted in container [forked] by utilitybend.

Why Techniques Like This Are Important

The best thing about using custom properties to handle calculations is that they are lighter and more performant than attempting to handle them in JavaScript. It takes some getting used to, but I believe that we should use these kinds of calculations a lot more often. Performance is such an important feature. Even seemingly minor optimizations like this can add up and really make a difference to the overall end-user experience.

And, as we’ve seen, we can plug in variables from other elements into the equation and use them to conform an element to the properties of another element. That’s exactly what we did to conform the .slider’s inner padding to the padding of a .container that is completely independent of the slider. That’s the power of CSS variables — reusability and modularity that can improve how elements interact within and outside other elements.

Computer programmers build web properties, software, and mobile apps. These specialists use programming languages like Ruby, Javascript, and C to accomplish this goal.

If you’re an aspiring software developer, it can be difficult to know which one to master. After all, there are dozens of programming languages available. The good news is that many programming languages have significant earning potential.

In this guide, we’ll cover the in-demand programming languages to master in your career.

The Highest-Paying Programming Languages by Average Salary

If you’re looking to advance your career and earn a high salary, you should learn and master these popular languages to get started:

• Python: $141,658 /year
• Ruby: $134,186 /year
• C++: $120,212 /year
• Golang: $120,086 /year
• Java: $117,931 /year
• Rust: $109,905 /year
• SQL: $109,407 /year
• Swift: $103,072/year

*All salaries are the US national average and sourced from ZipRecruiter

These aren’t only some of the highest-paying programming languages in the world, but they’re also the most popular.

Whether you take an online course, boot camp, or attend a community college, you shouldn’t have trouble learning these open-source programming languages.

How to Increase Your Earning Potential: Best Practices for Computer Programmers

It’s not enough to learn the highest-paying programming languages. If you want to become a successful computer scientist, here are some tips. 

Learn Different Programming Languages

There are dozens of programming languages in the world. Software development teams sometimes use several programming languages, artificial intelligence (AI), and machine learning to build dynamic mobile applications. 

On top of that, building integrations through APIs and SDKs means learning how different programming languages relate.

(Image Source)

To advance your career, you should invest time in learning different programming languages. This is especially true if you plan on working for Fortune 500 companies in the future. 

For example, Swift is commonly used in the Apple coding ecosystem. If working for Apple as a programmer is one of your career goals, Swift should definitely be on your priority list. 

Build Credibility

Another way to increase your earnings is by building credibility in your niche. There are several ways you can do this, including:

• Creating thought-leadership content: Do you have something new to share with other coders? If so, you can write for other websites and produce content showing your level of expertise. 
• Freelancing: You can also elevate your credibility by offering your services for side projects. This can give you some extra cash in your pocket, introduce you to new people, and expand your connections. 
• Contributing to open-source projects: Open-source projects require volunteer community members to stay afloat. If you contribute to developing new software, patches, desktop applications, web architecture, and updates, your work will last for a long time and even catch the eyes of prospective employers. 
• Participating in hackathons: These events feature countless hackers and computer programmers from all walks of life. Think of it as a networking opportunity – like LinkedIn, but for computer programmers and enthusiasts only.

Following these strategies can help you get your name out there, find new job opportunities, and connect with like-minded people who can become connections later. 

Continue Learning

The world of modern technology is always changing. The best computer programmers can stay on top of new developments and adapt their processes. There are many ways you can evolve your learning.

One way is by attending keynote speeches. Doing so lets you learn from some of the brightest minds in software testing. The good news is that these events are usually affordable and held in public places.

You can also meet other programmers and grow your network through public learning events. Another way you can continue your learning is by taking online boot camps.

(Image Source)

These online courses teach beginner, intermediate, and advanced web development trends. Upon completing a boot camp, you’ll receive a certificate, which you can add to your resume. 

Switch Companies

If you believe you’re stagnant in your current job, you should explore more opportunities. Software development is a continuously changing industry. The more ambitious you are as a computer programmer, the more likely you are to succeed over your peers. 

You should work with a company that’ll challenge you to learn something new daily and contribute to a world-changing project. 

Oh, and let’s not forget that you can see an average 15% salary increase when changing jobs. 

Start Your Own Business

Embarking on the journey of starting your own programming business can be a transformative step towards significantly increasing your earning potential. Start by doing some research and reading up on small business blogs to gain insights on starting and running a business.

Unlike traditional employment, running your own business in the tech industry means there’s no ceiling on how much you can earn. The more innovative and efficient your solutions are, the greater the demand and, consequently, the higher your potential income. 

Need inspiration? Ryan Hogue earned $85,000 a year as a full-time web developer. Now, he makes $14,600 a month in passive income. That’s an impressive jump. Talk about inspiring. 

However, an often overlooked but critical aspect of this process is the importance of registering your business with state authorities. This legal step is essential to avoid unnecessary fees or, worse, being denied the right to operate. 

By ensuring your business is registered and compliant with state and local regulations, you protect your venture and establish a foundation of credibility and trustworthiness in the market.

Final Words

Learning these popular programming languages can increase your earning potential and advance your career. 

It’s not uncommon for successful computer programmers to earn well over $100,000 a year or more in today’s digital world. Developer salaries are well above the median salary and some of the highest-paying jobs. 

If you’re ready to expand your horizons and learn some new programming languages, studying the ones in this guide is a great first step.

These languages are great for beginners because they’re often simple and easy to learn and have a wide range of applications.

You can use them for everything from web development to game design to software engineering. They’re constantly evolving, so new learning opportunities are always there across tech companies (or starting your own).

Here’s to your success as a software engineer or skilled developer! 

Featured Image by Kenny Eliason on Unsplash

The post Exploring the Top-Earning Opportunities: A Guide to the Highest Paid Programming Languages appeared first on noupe.

What makes a website great? Is it the design, the functionality, the subject? Or is it specific design elements like the typography, or colors?

If you’re looking for a fulfilling, lucrative career in tech, you can’t do much better than being a web developer. There’s just one issue: It’s extremely competitive. To snag your dream job, you’ll need more than just skills and desire. You’ll need to differentiate yourself during the entire interviewing process from making sure your resume gets noticed to wowing interviewers and employers into making an offer. 

Despite the challenges of landing a web development position, it can be well worth the effort to try. The U.S. News & World Report has listed “web developer” as the seventh-best STEM sector occupation and the ninth-best overall career. And those rankings aren’t likely to wane anytime soon. Employment opportunities for web developers are expected to grow significantly until at least 2031. At an average salary range of around $81,000, that’s a reason to get into the web developer game.

Ready to stand out as you pursue the web developer path? Put these innovative techniques into motion and you’ll position yourself for the outcome you want.

1. Ditch your old-style, single-template resume.

You might already know that plenty of companies rely on software programs to sift through the resumes they receive. Typically, those programs evaluate applicants on how well their resume information matches the job description. Resumes that contain appropriate keywords and candidate data will be more likely to reach human eyes.

In other words, your resume needs to be carefully tweaked every time you apply for a role. Yet it can be very time-consuming to rework your resume to fit each job opening. That’s where you can leverage the power of AI-fueled software. For instance, you might want to apply to one dozen or more web developer roles. Rather than manually updating and optimizing each one, turn to free software like Teal to do it for you. 

Teal offers job seekers a comprehensive platform that makes it easy to build your resume with AI and customize it to match closely with individual job descriptions. The company’s core SaaS product also provides users with a dashboard where they can track their customized resumes. Haven’t written your resume yet? No worries — Teal can make suggestions and keep your resume from falling through the cracks or being denied by an algorithm “gatekeeper.” 

2. Create an impressive portfolio.

Even if you’re somewhat new to web development, you’ll be expected to showcase your technical abilities. This is best done in an online portfolio that can be shared with potential employers. However, you don’t want to clutter your portfolio with junk or make it difficult to evaluate. Your portfolio should be streamlined and contain just enough samples to entice someone to ask for a first or second interview. (Or make you an offer!)

What belongs in your web developer portfolio? You should have some examples of projects that relate to the job you want. For example, let’s say an organization is looking for someone with extensive coding capabilities. Your portfolio should contain two to three examples of pages or site elements that you wrote the code for. Don’t just share the code. Describe the goal, talk about how you met the goal through coding, and illustrate the end result. This will paint a clear picture of the talents you’re bringing to the table. 

You can host your portfolio on any site you like, including on a read-only Google doc. Just be sure that you link to your portfolio on your resume. Don’t be afraid to include the link in your cover letter and, if applicable, your application form. Over time, be aware that you’ll need to update your portfolio and replace dated experiences with fresh ones.

3. Use social media to your benefit.

As with any field, web developers have online communities, forums, and groups. Consequently, you should become visible in these social communities. Present yourself as both a thought leader and an eager learner. For example, you might want to answer questions posed by others and post some questions yourself.

Publishing articles on LinkedIn can be another wait to gain some credibility among other IT professionals and corporate leaders. The same is true for posting, sharing, and commenting on Facebook and X, too. The more people you engage with in the IT sector, the higher your likelihood to hear about job openings — and get noticed. 

What if you’re comfortable in front of the camera or talking to a crowd? Setting up your own YouTube or Twitch channel devoted to web development could make sense. The higher your following, the more authority you naturally acquire. Plus, you may be able to make a little money on the side by coding live. Small-time Twitch streamers with 100+ viewers can net up to $1,500 monthly. That’s not exactly peanuts.

4. Stay up to date on the industry.

The world of technology is expanding and evolving at a faster-than-ever pace. In a flash, your knowledge can become outdated if you’re not keeping up. Therefore, it may be wise to invest in certificates or degrees, and the occasional coding bootcamp. (As a side note, bootcamps will offer the chance to meet peers and expand your network, which is a bonus advantage.)

Not sure where to start? There are many places that offer training to current and aspiring web developers. Some are well-known institutes of higher learning like Arizona State University and Capella University. However, other programs are run by companies known for web development. A helpful site for discovering short-term and long-term web development classes is Coursera. While Coursera offers some options that are branded to itself, others are through partnerships with universities and companies. For instance, Coursera features classes for learners at all levels from IBM. 

As you advance your continuing education credentials, be sure to add them into your resume as well as your LinkedIn profile. This step can be easy to forget, but it’s essential if you’re trying to highlight exactly what makes you a more appealing, well-versed candidate than someone else.

Web development might be a crowded field, but that doesn’t mean you can’t edge your way in. Just take a little time upfront to plan out your career strategy. Then, go forward with gusto. Someone has to land every job that’s available — and the next person who hears “You’re hired!” could be you.

Featured Image by James Harrison on Unsplash

The post How to Land the Web Development Job of Your Dreams appeared first on noupe.

When you’re dealing with network issues, the go-to solution that often comes to mind is using a ping monitoring tool. Why? Because it’s the quickest and ?asi?st way to check if your s?rv?rs or d?vic?s can talk to ?ach oth?r ov?r th? n?twork. It’s lik? a virtual handshak? to s?? if ?v?rything is okay. 

Ping monitoring tools help you keep an ?y? on your int?rn?t protocol (IP) and r?lat?d compon?nts. Th?s? tools l?t you manage and watch over your connections, making sure your n?twork is doing its job – k??ping syst?ms conn?ct?d and running smoothly. 

By using a ping monitoring tool, you can quickly v?rify if your conn?ctions are working as they should. It’s lik? a n?twork h?alth ch?ck to see if your systems ar? up and running or if th?r?’s a hiccup. 

Now, let’s div? into th? world of ping monitoring and explore some of th? b?st tools out there to help you monitor and fix any n?twork hiccups. 

How Ping Monitoring Works?

By doing Ping tests regularly, you can figure out the fastest, slowest, and average times for the device to respond. We call this time between sending the signal and getting a response the “ping time,” usually measured in milliseconds (ms). The lower the ping time, the better – it means your network is speedy and in good shape.

Ping monitoring is lik? s?nding a fri?ndly signal to a d?vic? or comput?r and ch?cking how quickly it r?sponds. It’s lik? saying “h?llo” to s?? if ?v?rything is working smoothly. If the d?vic? replies fast, it’s a good ping, but if it takes too long, it’s considered bad. 

Here’s the technical bit: ping sends a special message called an Internet Control Message Protocol (ICMP) echo request to a specific spot on the network. When that spot gets the message, it quickly replies with an echo to confirm it got the signal. So, ping monitoring is like a quick conversation to make sure everything is running smoothly in your network.

Top 5 Ping Tools 

Here are the top five ping tools that can help spot issues by providing real-time network info.

SolarWinds Ping Monitor Tool

With SolarWinds Ping Monitor Software, you can easily keep an eye on how quickly devices respond. All you have to do is pick the device you want to watch. This software lets you share monitoring data using text files or show it off with images or graphs.

And it’s not just about pinging! SolarWinds comes with a bunch of cool features. You get a WAN Killer Traffic Generator, a MAC Address Scanner, an SNMP MIB Browser, a Ping Sweep, a Subnet Calculator, an MIB Walk, a Switch Port Mapper, and a whole lot more. It’s like having a superhero toolkit for checking and managing your network.

Site24x7 

The Network Monitor part of the Site 24×7 is smart. It uses the ping monitor to find all the gadgets connected to your network and creates a list of them. Then, it takes this info and makes a cool map to show you how everything is connected. Regular check-ups make sure this map is always up to date.

Site24x7 is like a superhero for monitoring everything related to your online world – websites, cloud, servers, networks, applications, and even how real users experience your site. It keeps an eye on important things like how fast your site responds and if it’s available, giving you useful metrics. Among the basic monitors in Site24x7, you find ping alongside other friends like HTTP/HTTPS, WebSocket, DNS, and FTP, NTP, or SMTP servers.

PingPlotter 

PingPlotter Pro is a great tool for checking how your network is doing. It works on Windows, Mac OS, and iOS, and you can even keep an eye on things remotely through a web interface. This means you can monitor lots of devices from one place.

For a quick look at your n?twork’s h?alth, PingPlott?r Pro has summary scr??ns and jitt?r graphs. Th?s? h?lp admins s?? what’s going on with just a glanc? at th? data. But what r?ally stands out is its trac?rout? f?atur?. 

With a us?r-fri?ndly int?rfac?, it shows you th? tim? it tak?s for data to travel and any loss?s that happen along th? way. It’s lik? following a virtual trail of data from point to point, giving admins a cl?ar vi?w of what’s happ?ning in their n?twork and making it ?asi?r to spot and fix problems. 

Better Stack

B?tt?r Stack is like a superhero for keeping an ?y? on your onlin? stuff. It does a bunch of cool things, like checking if your w?bsit? is up, managing incidents, and letting p?opl? know if th?r?’s downtim? through status pages. 

With B?tt?r Stack, you g?t ch?cks for all kinds of things – k?ywords in URLs, multipl? v?rification st?ps, heartbeat ch?cks, SSL, ping, and port monitoring. It’s lik? having a virtual sup?rh?ro squad, making sure ?v?rything runs smoothly. Plus, it plays nic? with oth?r tools you might already be using,  lik? Datadog, N?w R?lic, Grafana, and mor?. 

Here’s the neat part: Better Stack checks your website every 30 seconds, not just from one place but from different locations. This means no more false alarms or missing issues that depend on where you are.

If something goes wrong, Better Stack doesn’t just tell you there’s a problem – it shows you exactly what happened with screenshots and a timeline. You can use its reports and analytics to look back at how well your site has been doing, check if it meets service level agreements (SLA), and understand incidents better.

iplocation.io

The Ping test tool by iplocation.io is like a handy helper for people who want to check if a website, domain, or IP address is working okay. It’s super easy to use – you just open it, type in the website or IP address you’re curious about, and hit the “Ping Now” button.

After that, the tool gives you some useful info. If ?v?rything’s good, and no data is lost, it m?ans th? conn?ction is solid,  and th? thing you’re ch?cking is onlin?. But if th?r?’s data loss, it could m?an th? connection isn’t r?liabl?. 

If th? tool tim?s out, it’s lik? a littl? r?d flag. It might m?an th?r?’s an issue with th? IP addr?ss,  th? thing you’r? ch?cking is offlin?, or th?r?’s som?thing in th? way that’s stopping it from r?sponding to ping r?qu?sts. 

Final Words  

For IT professionals, it’s crucial to know if their important s?rv?rs and n?twork gadg?ts ar? doing well or if they sudd?nly go offlin?. A ping tool is lik? a helpful buddy in this situation. It constantly sends r?qu?sts to your important n?twork d?vic?s, making sur? ?v?rything ar? okay. 

Using a ping monitoring app is smart because it doesn’t hog up a lot of your network’s power.  This means you can k??p your s?rvic?s running smoothly without slowing down your whole network or internet connection. How you s?t up your ping monitoring d?p?nds on what you need, but with a littl? digging and t?sting, you can find th? b?st way to k??p your n?twork in top shap?. 

Featured image by U. Storsberg on Unsplash

The post Top 5 IP Ping Tools appeared first on noupe.

This article is a sponsored by DebugBear

There’s a change coming to the Core Web Vitals lineup. If you’re reading this before March 2024 and fire up your favorite performance monitoring tool, you’re going to to get a Core Web Vitals report like this one pulled from PageSpeed Insights:

You’re likely used to seeing most of these metrics. But there’s a good reason for the little blue icon sitting next to the second metric in the second row, Interaction to Next Paint (INP). It’s the newest metric of the bunch and is set to formally be a ranking factor in Google search results beginning in March 2024.

And there’s a good reason that INP sits immediately below the First Input Delay (FID) in that chart. INP will officially replace FID when it becomes an official Core Web Vital metric.

The fact that INP is already available in performance reports means we have an opportunity to familiarize ourselves with it today, in advance of its release. That’s what this article is all about. Rather than pushing off INP until after it starts influencing the way we measure site performance, let’s take a few minutes to level up our understanding of what it is and why it’s designed to replace FID. This way, you’ll not only have the information you need to read your performance reports come March 2024 but can proactively prepare your website for the change.

“I’m Not Seeing Those Metrics In My Reports”

Chances are that you’re looking at Lighthouse or some other report based on lab data. And by that, I mean data that isn’t coming from the field in the form of “real” users. You configure the test by applying some form of simulated throttling and start watching the results pour in. In other words, the data is not looking at your actual web traffic but a simulated environment that gives you an approximate view of traffic when certain conditions are in place.

I say all that because it’s important to remember that not all performance data is equal, and some metrics are simply impossible to measure with certain types of data. INP and FID happen to be a couple of metrics where lab data is unsuitable for meaningful results, and that’s because both INP and FID are measurements of user interactions. That may not have been immediately obvious by the name “First Input Delay,” but it’s clear as day when we start talking about “Interaction to Next Paint” — it’s right there in the name!

Simulated lab data, like what is used in Lighthouse reports, does not interact with the page. That means there is no way for it to evaluate the first input a user makes or any other interactions on the page.

So, that’s why you’re not seeing INP or FID in your reports. If you want these metrics, then you will want to use a performance tool that is capable of using real user data, such as DebugBear, which can monitor your actual traffic on an ongoing basis in real time, or PageSpeed Insights which bases its finding on Google’s “Chrome User Experience Report” (commonly referred to as CrUX), though DebugBear is capable of providing CrUX reporting as well. The difference between real-time user monitoring and measuring performance against CrUX data is big enough that it’s worth reading up on it, and we have a full article on Smashing Magazine that goes deeply into the differences for you.

INP Improves How Page Interactions Are Measured

OK, so we now know that both INP and FID are about page interactions. Specifically, they are about measuring the time between a user interacting with the page and the page responding to that interaction.

What’s the difference between the two metrics, then? The answer is two-fold. First, FID is a measure of the time it takes the page to start processing an interaction or the input delay. That sounds fine on the surface — we want to know how much time it takes for a user to start an interaction and optimize it if we can. The problem with it, though, is that it takes just one part of the time for the page to fully respond to an interaction.

A more complete picture considers the input delay in addition to two other components: processing time and presentation delay. In other words, we should also look at the time it takes to process the interaction and the time it takes for the page to render the UI in response. As you may have already guessed, INP considers all three delays, whereas FID considers only the input delay.

The second difference between INP and FID is which interactions are evaluated. FID is not shy about which interaction it measures: the very first one, as in the input delay of the first interaction on the page. We can think of INP as a more complete and accurate representation of how fast your page responds to user interactions because it looks at every single one on the page. It’s probably rare for a page to have only one interaction, and whatever interactions there are after the first interaction are likely located well down the page and happen after the page has fully loaded.

So, where FID looks at the first interaction — and only the input delay of that interaction — INP considers the entire lifecycle of all interactions.

Measuring Interaction To Next Paint

Both FID and INP are measured in milliseconds. Don’t get too worried if you notice your INP time is greater than your FID. That’s bound to happen when all of the interactions on the page are evaluated instead of the first interaction alone.

Google’s guidance is to maintain an FID under 100ms. And remember, FID does not take into account the time it takes for the event to process, nor does it consider the time it takes the page to update following the event. It only looks at the delay of the event process.

And since INP does indeed take all three of those factors into account — the input delay, processing time, and presentation delay — Google’s guidance for measuring INP is inherently larger than FID: under 200ms for a “good” result, and between 200-500ms for a passing result. Any interaction that adds up to a delay greater than 500ms is a clear bottleneck.

The goal is to spot slow interactions and optimize them for a smoother user experience. How exactly do you identify those problems? That’s what we’re looking at next.

Identifying Slow Interactions

There’s already plenty you can do right now to optimize your site for INP before it becomes an official Core Web Vital in March 2024. Let’s walk through the process.

Of course, we’re talking about the user doing something on the page, i.e., an action such as a click or keyboard focus. That might be expanding a panel in an accordion component or perhaps triggering a modal or a prompt any change in a state where the UI updates in response.

Your page may consist of little more than content and images, making for very few, if any, interactions. It could just as well be some sort of game-based UI with thousands of interactions. INP can be a heckuva lot of work, but it really comes down to how many interactions we’re talking about.

We’ve already talked about the difference between field data and lab data and how lab data is simply unable to measure page interactions accurately. That means you will want to rely on field data when pulling INP reports to identify bottlenecks. And when we’re talking about field data, we’re talking about two different flavors:

1. Data from the CrUX report that is based on the results of real Chrome users. This is readily available in PageSpeed Insights and Google Search Console, not to mention DebugBear. If you use either of Google’s tools, just note that their throttling methods collect metrics on a fast connection and then estimate how fast the page would be on a slower connection. DebugBear actually tests with a slower network, resulting in more accurate data.
2. Monitoring your website’s real-time traffic, which will require adding a snippet to your source code that sends traffic data to a service. And, yes, DebugBear is one such service, though there are others. You can even take advantage of historical CrUX data integrated with BigQuery to get a historical view of your results dating back as far as 2017 with new data coming in monthly, which isn’t exactly “real-time” monitoring of your actual traffic, but certainly useful.

You will get the most bang for your buck with real-time monitoring that keeps a historical record of data you can use to evaluate INP results over time.

That said, you can still start identifying bottlenecks today if you prefer not to dive into real-time monitoring right this second. DebugBear has a tool that analyzes any URL your throw at it. What’s great about this is that it shows you the elements that receive user interaction and provides the results right next to them. The result of the element that takes the longest is your INP result. That’s true whether you have one component above the 500ms threshold or 100 of them on the page.

The fact that DebugBear’s tool highlights all of the interactions and organizes them by INP makes identifying bottlenecks a straightforward process.

See that? There’s a clear INP offender on Smashing Magazine’s homepage, and it comes in slightly outside the healthy INP range for a score of 510ms even though the next “slowest” result is 184ms. There’s a little work we need to do between now and March to remedy that.

Notice, too, that there are actually two scores in the report: the INP Debugger Result and the Real User Google Data. The results aren’t even close! If we were to go by the Google CrUX data, we’re looking at a result that is 201ms faster than the INP Debugger’s result — a big enough difference that would result in the Smashing Magazine homepage fully passing INP.

Ultimately, what matters is how real users experience your website, and you need to look at the CrUX data to see that. The elements identified by the INP Debugger may cause slow interactions, but if users only interact with them very rarely, that might not be a priority to fix. But for a perfect user experience, you would want both results to be in the green.

Optimizing Slow Interactions

This is the ultimate objective, right? Once we have identified slow interactions — whether through a quick test with CrUX data or a real-time monitoring solution — we need to optimize them so their delays are at least under 500ms, but ideally under 200ms.

Optimizing INP comes down to CPU activity at the end of the day. But as we now know, INP measures two additional components of interactions that FID does not for a total of three components: input delay, processing time, and presentation delay. Each one is an opportunity to optimize the interaction, so let’s break them down.

Reduce The Input Delay

This is what FID is solely concerned with, and it’s the time it takes between the user’s input, such as a click, and for the interaction to start.

This is where the Total Blocking Time (TBT) metric is a good one because it looks at CPU activity happening on the main thread, which adds time for the page to be able to respond to a user’s interaction. TBT does not count toward Google’s search rankings, but FID and INP do, and both are directly influenced by TBT. So, it’s a pretty big deal.

You will want to heavily audit what tasks are running on the main thread to improve your TBT and, as a result, your INP. Specifically, you want to watch for long tasks on the main thread, which are those that take more than 50ms to execute. You can get a decent visualization of tasks on the main thread in DevTools:

The bottom line: Optimize those long tasks! There are plenty of approaches you could take depending on your app. Not all scripts are equal in the sense that one may be executing a core feature while another is simply a nice-to-have. You’ll have to ask yourself:

• Who is the script serving?
• When is it served?
• Where is it served from?
• What is it serving?

Then, depending on your answers, you have plenty of options for how to optimize your long tasks:

• Use Web Workers to establish separate threads for tasks to get scripts off the main thread.
• Split JavaScript bundles into individual pieces for smaller payloads.
• Async or defer scripts that can run later without affecting the initial page load.
• Preconnect network connections, so browsers have a hint for other domains they might need to connect to. (It’s worth noting that this could reveal the user’s IP address and conflict with GDPR compliance.)

Or, nuke any scripts that might no longer be needed!

Reduce Processing Time

Let’s say the user’s input triggers a heavy task, and you need to serve a bunch of JavaScript in response — heavy enough that you know a second or two is needed for the app to fully process the update.

• Try creating a loading state that triggers immediately and perform the work in a setTimeout() callback because that’s a much quicker way to respond to the user interaction than waiting for the complete update.
• If you’re working in React, make sure you are preventing your components from re-rendering unnecessarily.
• Remember that alert(), confirm(), and prompt() are capable of adding to the total processing time as they run synchronously and block the main thread. That said, it appears there could be plans to change that behavior ahead of INP becoming a formal Core Web Vital.

Reduce Presentation Delay

Reducing the time it takes for the presentation is really about reducing the time it takes the browser to display updates to the UI, paint styles, and do all of the calculations needed to produce the layout.

Of course, this is entirely dependent on the complexity of the page. That said, there are a few things to consider to help decrease the gap between when an interaction’s callbacks have finished running and when the browser is able to paint the resulting visual changes.

One thing is being mindful of the overall size of the DOM. The bigger the DOM, the more HTML that needs to be processed. That’s generally true, at least, even though the relationship between DOM size and rendering isn’t exactly 1:1; the browser still needs to work harder to render a larger DOM on the initial page load and when there’s a change on the page. That link will take you to a deep explanation of what contributes to the DOM size, how to measure it, and approaches for reducing it. The gist, though, is trying to maintain a flat structure (i.e., limit the levels of nested elements). Additionally, reviewing your CSS for overly complex selectors is another piece of low-hanging fruit to help move things along.

While we’re talking about CSS, you might consider looking into the content-visibility property and how it could possibly help reduce presentation delay. It comes with a lot of considerations, but if used effectively, it can provide the browser with a hint as far as which elements to defer fully rendering. The idea is that we can render an element’s layout containment but skip the paint until other resources have loaded. Chris Coyier explains how and why that happens, and there are aspects of accessibility to bear in mind.

And remember, if you’re outputting HTML from JavaScript, that JavaScript will have to load in order for the HTML to render. That’s a potential cost that comes with many single-page application frameworks.

Gain Insight On Your Real User INP Breakdown

The tools we’ve looked at so far can help you look at specific interactions, especially when testing them on your own computer. But how close is that to what your actual visitors experience?

Real user-monitoring (RUM) lets you track how responsive your website is in the real world:

• What pages have the slowest INP?
• What INP components have the biggest impact in real life?
• What page elements do users interact with most often?
• How fast is the average interaction for a given element?
• Is our website less responsive for users in different countries?
• Are our INP scores getting better or worse over time?

There are many RUM solutions out there, and DebugBear RUM is one of them.

DebugBear also supports the proposed Long Animation Frames API that can help you identify the source code that’s responsible for CPU tasks in the browser.

Conclusion

When Interaction to Next Paint makes its official debut as a Core Web Vital in March 2024, we’re gaining a better way to measure a page’s responsiveness to user interactions that is set to replace the First Input Delay metric.

Rather than looking at the input delay of the first interaction on the page, we get a high-definition evaluation of the least responsive component on the page — including the input delay, processing time, and presentation delay — whether it’s the first interaction or another one located way down the page. In other words, INP is a clearer and more accurate way to measure the speed of user interactions.

Will your app be ready for the change in March 2024? You now have a roadmap to help optimize your user interactions and prepare ahead of time as well as all of the tools you need, including a quick, free option from the team over at DebugBear. This is the time to get a jump on the work; otherwise, you could find yourself with unidentified interactions that exceed the 500ms threshold for a “passing” INP score that negatively impacts your search engine rankings… and user experiences.