Forem: abbiecoghlan

Semantic HTML for improved accessibility and SEO

abbiecoghlan — Mon, 07 Jun 2021 01:44:33 +0000

What is a Semantic HTML element?

A Semantic HTML element is an element that clearly describes its own meaning through its name. For example, <header> is a semantic html element, and <div> is not. When you use <header>, it communicates to the browser that that portion of your website is the header. If you were to use <div> instead, although your content might look the same to many users, you haven’t communicated to the browser any information about the fact that it is your website’s header.

Examples

There are many semantic HTML elements. Some of the most common semantic elements include:
<header>: a header element is used for the web page header. A header may include a logo, title for the page, and site navigation.
<nav>: A nav element includes links to other pages of the website, or links to anchors on the same page. It is often placed inside of a header or footer element.
<footer>: a footer element may contain nav links, links to contact information, and information about the ownership of the website.
<main> Main is an element that is used to hold the main content of the page, and should be used for information that is unique to that page.
<article>: The article element is used for content that is a self-contained and independent part of a website. Information in this section should be able to stand alone and make sense without any additional context. It is used for things like blog posts, newspaper articles, or forum posts.

Benefits of Semantic Elements

Semantic HTML elements don’t take any longer to write than non-semantic elements, and using semantic elements provide many benefits. Semantic elements provide information about how your document is organized and what each element contains. When you use a semantic element, you are communicating more specific information about the document to the browser. This is important for accessibility as well as SEO. When you use a semantic element, you improve your website’s accessibility for users across the world, especially for users who use screen readers. Without semantic elements, screen readers have less information to utilize to adapt content so that users can access information accurately. Search engines give more importance to key words inside semantic elements, so your website will be easier to find than it would be if you used non-semantic elements. If you use semantic elements, you also have the option to use them as hooks for CSS styling without needed to assign additional class names or IDs.

Common Mistakes

Many people utilize non-semantic elements or misuse elements in order to achieve styling effects, rather than using css to achieve the same effect. Here are some common mistakes and solutions:

Common Mistake 1: using a block quote when you want content indented

Many developers will us the block quote element when they want content indented, as it is a quick way to achieve that styling. If information inside of a block quote is not an actual piece of quoted information, you should not use it. Rather, you should use a different, more accurate element, and use CSS to style the margins to achieve the same impact.

Common Mistake 2: using a p tag to add extra space

Another common misuse of elements is the use of a

tag to add extra space between elements. Again, this is done because it is a quick and easy way to achieve a desired visual styling. However, this communicates misinformation about the content of that section to your browser. Again, the solution here is to utilize css to add margins and padding as needed for the same visual impact.

Common Mistake 3: misuse of header tags

h1-h6 tags are often chosen based on a desire font size. However, this again miscommunicates information to the browser for screen readers and search engines. Rather than choosing a heading tag based on font size, tags should be chosen based on content. An h1 tag is particularly important for SEO, and should be the main title of the page, communicating the main idea of what the page is about. An accurate h1 tag will make your website much more accessible by search. In general, header tags should convey a hierarchy of importance. If you list out out your header tags, you should have a sort of “outline” of your website. If you want the styling or size of these elements to change, you should utilize css to target font-size and font-weight properties rather than changing the tag.

Conclusion

Semantic HTML tags are important and beneficial for accessibility and SEO. They provide more information about the organization of your website and its content to search engines and screen readers. It is easy to utilize semantic HTML if you keep it in mind from the start of your project.

Ruby Modules: include vs extend vs prepend

abbiecoghlan — Wed, 20 Jan 2021 17:24:49 +0000

Previously, we learned about the differences between class inheritance and modules in Ruby. You can read more about that here. In that post, we reviewed how to use modules to share functionality between classes that do not have a clear hierarchical arrangement. Specifically, we used the include keyword to give our classes access to instance methods. In this post, we will focus on digging deeper into modules in Ruby by reviewing the use of the include keyword and introducing two other keywords, extend and prepend. Understanding the different behaviors of each of these three keywords and knowing when to use them will provide us with the power to utilize modules to extend functionality to our classes in a variety of ways.

`include`

include is the keyword that we will use within our classes to provide access to the methods defined in a module as instance methods in our class. In order to do so, we will first define a module.

module IndoorPet
    def can_be_housebroken?
        true
    end
end

Now, all we have to do to give our classes access to the instance method can_be_housebroken? as it is defined in our IndoorPet module is add include IndoorPet in the body of our class when we define it.

class Animal 
end 

class Dog < Animal 
    include IndoorPet
end 

class Cat < Animal
    include IndoorPet
end 

class Rabbit < Animal 
    include IndoorPet
end


roger = Rabbit.new("Roger")

roger.can_be_housebroken?
=> true 

Rabbit.can_be_housebroken?
=> NoMethodError: undefined method `can_be_housebroken?' for Rabbit:Class

With that, we have now included the module's instance method can_be_housebroken? in our Dog, Cat, and Rabbit classes. Thus, any instances of those classes will now have access to the can_be_housebroken? method.

When you include a module, Ruby will insert the module into the class's ancestry chain just above our class, between our class and it's superclass. This chain can be seen when calling .ancestors on our Rabbit class.

Rabbit.ancestors
=> [Rabbit, IndoorPet, Animal, Object, PP::ObjectMixin, Kernel, BasicObject]

`extend`

Now that we know how to use include to provide a class with access to a module's instance methods, you might be wondering how to provide a class with access to a module's class methods. The extend keyword does just that. It is used in exactly the same way as include, except that instead of instance methods which can be called on individual instances of our class, all of the methods we are extending to our class will be provided as class methods we can call on the class as a whole.

Instead of including can_be_housebroken? as instance method, let's try extending it as a class method. First, we define our module.

module IndoorPet
    def can_be_housebroken?
        true
    end
end

Then we use the extend keyword the same way we used the include keyword previously.

class Animal 
end 

class Dog < Animal 
    extend IndoorPet
end 

class Cat < Animal
    extend IndoorPet
end 

class Rabbit < Animal 
    extend IndoorPet
end



roger = Rabbit.new("Roger")

roger.can_be_housebroken?
=> NoMethodError: undefined method `can_be_housebroken?' for  #<Rabbit:0x00007fa84389c748> 

Rabbit.can_be_housebroken?
=> true

With that, we have now extended the module's class method can_be_housebroken? to our Dog, Cat, and Rabbit classes. Now those classes as a whole have access to the can_be_housebroken? method. Note that you can no longer call can_be_housebroken? on an individual instance of the class. With extend, we have only given the method to the class as a class method.

When you extend a module, ruby will provide the module's methods to the class as class methods. However, unlike with include, when you extend a module, Ruby will not insert the module into the class's ancestry chain. We can see this by calling .ancestors on our Rabbit class.

Rabbit.ancestors
=> [Rabbit, Animal, Object, PP::ObjectMixin, Kernel, BasicObject]

`prepend`

The third keyword for providing a module's methods to a class is prepend. We can use prepend in the same way we would use include or extend by first defining the module and then using the keyword and name of the module within the class's definition, as below.

module IndoorPet
    def can_be_housebroken?
        true
    end
end  


class Animal 
end 

class Dog < Animal 
    prepend IndoorPet
end 

class Cat < Animal
    prepend IndoorPet
end 

class Rabbit < Animal 
    prepend IndoorPet
end

In many ways, prepend operates like include. Both provide a class access to a module's methods as instance methods. Therefore, we can call the imported methods that we have prepended from our module on specific instances of a class, and not on the class itself.

roger = Rabbit.new("Roger")

roger.can_be_housebroken?
=> true 

Rabbit.can_be_housebroken?
NoMethodError: undefined method `can_be_housebroken?' for Rabbit:Class

However, the difference between include and prepend is related to the location in the ancestry chain where the module is placed. With prepend, the module is not inserted between the class and it's superclass as it was with include. It is actually inserted at the very bottom of the ancestry chain, as seen below.

Rabbit.ancestors
=> [IndoorPet, Rabbit, Animal, Object, PP::ObjectMixin, Kernel, BasicObject]

The importance of this distinction will be explored further in our next post!

`include` vs `extend` vs `prepend`

`include`

Provides a class with access to a module's methods as instance methods
Allows the methods to be called on individual instances of the class
Does not allow methods to be called on the class as a whole
Inserts module into ancestry chain between the class and superclass

`extend`

Provides a class with access to a module's methods as class methods
Does not allow the methods to be called on individual instances of the class
Allows methods to be called on the class as a whole

`prepend`

Provides a class with access to a module's methods as instance methods
Allows the methods to be called on individual instances of the class
Does not allow methods to be called on the class as a whole
Inserts module at the bottom of the ancestry chain

Class Inheritance VS Modules in Ruby

abbiecoghlan — Mon, 04 Jan 2021 18:53:17 +0000

In Ruby, we can use either class inheritance or modules to provide shared functionality throughout a program. This post explores the difference between class inheritance and modules, and considerations to help determine the appropriate use of each.

Class Inheritance

Inheritance between classes in Ruby allows for the creation of classes that have access to shared methods while still maintaining distinct, unique classes. When one class, known as the child or subclass, is inherited from another class, known as the parent or “super” class, it is given access to all of the methods of the parent. For example, we might have a parent class “Dog”, with a child class of “Dalmatian”. In the code below, we define these classes without the use of inheritance.

class Dog

    def bark
        "Woof!"
    end

    def sleep
        "zzzzz"
    end

    def find_that_smell
        "sniff sniff sniff"
    end

end

class Dalmatian

    def bark
        "Woof!"
    end

    def sleep
        "zzzzz"
    end

    def find_that_smell
        "sniff sniff sniff"
    end

end

The acronym DRY stands for "don't repeat yourself", and it is an important principle in software design. In the code below, using class inheritance, we can get the same functionality as above, but we have the benefit of keeping our code DRY. Our Dalmatian class now has access to all of the behavior of the Dog class.

class Dog

    def bark
        "Woof!"
    end

    def sleep
        "zzzzz"
    end

    def find_that_smell
        "sniff sniff sniff"
    end

end

class Dalmatian < Dog

end

The use of inheritance allows us to share methods between classes in a way that reflects the real-world hierarchical relationship between our classes, and provides shared functionality accordingly. If a dog can bark, a Dalmatian can bark.

An important note about class inheritance when considering use is that, although you can inherit from a class that inherits from another class that inherits from yet another class- a single class can only inherit from one class at a time when it is defined.

Modules

Let's imagine we wanted to define an instance method that returns true if the animal is able to be housebroken. We could define this as an instance method within our dog class and have our individual dog breeds inherit the method. But what if our program had other animal classes, such as cats and rabbits, that we wanted to provide this method to as well?

class Animal 
end 

class Dog < Animal 
    def can_be_housebroken?
        true
    end 
end 

class Cat < Animal
    def can_be_housebroken?
        true
    end 
end 

class Rabbit < Animal 
    def can_be_housebroken?
        true
    end 
end

As you can see above, we would have to define those methods over and over again. Sometimes, as in this case, we might want to share functionality between classes that do not have a clear hierarchical arrangement. Instead of making a new class that is built from the blueprint of an existing class, like when we inherit, we may simply want to group methods together and make those methods available to a variety of other classes. Modules allow us to do just that.

Let’s use a module instead of class inheritance. First, we will define our module. Then, within the definition of our classes, we can use the keyword include along with the module name in any number of classes in which we would like to provide access to the functions we defined in our module.

module IndoorPet
    def can_be_housebroken?
        true
    end
end  

class Animal 
end 

class Dog < Animal 
    include IndoorPet
end 

class Cat < Animal
    include IndoorPet
end 

class Rabbit < Animal 
    include IndoorPet
end

As you can see, the use of Modules provides a great solution for extending functionality and avoiding repetitive code in situations where there is no clear parent-child relationship. Once it is defined, a module can be included in many classes. There is also no limit to how many modules you can include in an individual class. One thing to keep in mind about modules when considering use is that, unlike with classes, you cannot have an instance of a module.

Class Inheritance vs Modules

Class inheritance and modules both allow us to extend functionality throughout our program while reducing repetitive code. When trying to figure out when to use modules vs class inheritance, some considerations include whether or not you need to create instances, whether or not there is a hierarchical relationship between classes, and how the extended functionality is related to the relationships between groups. If you are trying to build a class from the framework of an already defined class, you can use class inheritance to adopt the behaviors of a parent class. If you've created a group of methods that you’d like to use repeatedly throughout your program in many different classes that are not hierarchically related, you can use modules to provide your classes access to the methods defined within your modules.

In our next post, we dig deeper into modules in ruby, exploring the include, extend, and prepend keywords. You can read that post here.