DEV Community: Gyau Boahen Elvis

Carbon: The new C++?

Gyau Boahen Elvis — Mon, 26 Aug 2024 13:33:13 +0000

A large number of the most effective programming languages available today descended from earlier languages. C++, for instance, was developed to improve up the powerful yet fearsome C, a language that makes it so so easy to shoot yourself in the foot. TypeScript emerged from the messy JavaScript, while Kotlin stepped up to refine Java's complexity. Objective-C made way for the elegant Swift. It's a cycle of evolution, each language learning from the flaws of its forerunners to become sharper, safer, and more efficient.

The Big Question we wish to answer after this video is after C++, what comes next?

But wait, is there supposed to be something beyond C++? Sure, C++ is a powerhouse, but it's also a beast to handle. You almost need four legs to keep up because C++ is notoriously tough. This complexity makes fast, scalable development a real challenge. Compared to other languages, C++ can slow you down with its careful memory management. And With error messages looking like Shakespeare's poems, it will take you years to build something you'll build in days in other languages. The language's commitment to backward compatibility with C adds to its technical debt it has accumulated over the years, making modernization a headache. Unlike JavaScript's npm or Python's pip3, C++ lacks a default package manager, forcing developers to juggle dependencies manually.

According to Bjarne Stroustrup, the creator of C++, in his book Design and Evolution of C++, he stated that within C++, there is a much smaller and cleaner language struggling to get out.

Is it Rust? Dear Rustaceans, Rust is great, but no. Rust isn't the cleaner and smaller language Bjarne Stroustrup was referring to. One reason is that Rust isn't interoperable with C++, and besides, Rust's performance doesn't match that of C++. C++ has been used to build numerous applications across various industries, and no developer ever wants to undertake the daunting task of converting an entire C++ codebase, especially a large one, to a different programming language.

At the C++ Conference in Toronto in July 2022, Google's engineer Chandler Carruth introduced Carbon, an experimental successor to C++ built with using LLVM, with low-level access to bits and addresses. This new language is designed to provide seamless access to the entire C++ ecosystem, building on and around it. Google's aim isn't necessarily to have all developers abandon their C++ code but to offer a viable alternative for those who may benefit from a different approach.

Just as some developers have shifted entirely to TypeScript, even though JavaScript is still widely used, Carbon could become the go-to for certain workflows while others continue with C++. The idea isn't to replace C++ entirely, but to provide options, just like TypeScript has done for JavaScript.

Carbon has bidirectional interoperability with C++, allowing you to use Carbon code in C++ and vice versa. This makes it easier for engineers to migrate C++ codebases to Carbon or build upon C++ with Carbon. Designed for performance-critical applications, Carbon also offers a gentle learning curve, thanks to its simple syntax and introducer keywords. This simplicity makes Carbon easy to parse for humans, IDEs, and compilers—unlike C++.

For instance, if you search for 'the most vexing parse,' you'll find a C++ example on Wikipedia. It's a notorious issue that highlights the complexity of C++, making Carbon's ease of use even more valuable.

It is designed to be a memory-safe language that makes it very difficult and almost impossible to shoot yourself in the foot and even when you do, there will be tools and simple sentences and easy-to-understand error messages to bail you out. Let's look at some code.

Esoteric Languages: What are they, and why you should be concerned?

Gyau Boahen Elvis — Fri, 02 Feb 2024 05:46:00 +0000

In the dimension of programming languages, certain languages are widely regarded as proficient and effective, including TypeScript, Kotlin, and Rust, among others. On the other hand, some may express reservations about languages like PHP, Java, and Perl, deeming them as less favorable.
Beyond the conventional languages are a category of programming languages known as Esoteric languages. These are languages invented seemingly to make developers cringe at the mere mention of their names.

Can you imagine a programming language that only recognizes eight characters? Anything else written in this language, apart from the recognized characters < > [ ] , . + -, is considered a comment. It might seem impossible! One notable example is Brainfuck, a language that executes only the characters mentioned; any other character used in coding is treated as a comment.

In this article, we will delve deeper into Esoteric programming languages (esolangs for short). We'll explore five examples of the most bizarre Esolangs out there, and, to top it off, we will attempt to write hello world in some of these languages, if it's possible. Are you curious to learn more about Esolangs? Put on your helmet, and let's ride together because it's going to be a long but exciting journey.

What are Esoteric Languages?

These are programming languages created for fun, code obfuscation, or as an experiment in pushing the boundaries of programming.

Esolangs are designed to be nothing like the conventional languages developers are used to. They are the outlaws of the programming dimension that are intentionally created to have features that deviate from the normal programming languages, either as a joke or just to push the boundaries of programming languages a little further. The intention of esolang designers is not for these languages to be used in mainstream programming, although some of these languages have led to emphasis and conversations about some mainstream programming language features.

Time to get our hands dirty. Let's dig into some of the most popular and interesting Esolangs out there.

1. Compiler Language With No Pronounceable Acronym (INTERCAL)

Imagine a scenario where including the keyword Please in your code is mandatory; otherwise, the compiler deems it impolite and rejects the code. Striking a balance is crucial because too few Please might be interpreted as rudeness, while an excess of politeness might also lead to rejection. Think it's impossible? Allow me to introduce you to the Compiler Language With No Pronounceable Acronym, abbreviated as INTERCAL—a name chosen for reasons only known to its creators, Don Woods and James M. Lyon.

INTERCAL was created in 1970 to be nothing like the conventional programming languages. It intentionally contains puzzling and redundant features; it defies the norms of typical programming languages, which make it impossible to understand.

Hello World in INTERCAL



DO ,1 <- #13
PLEASE DO ,1 SUB #1 <- #238
DO ,1 SUB #2 <- #108
DO ,1 SUB #3 <- #112
DO ,1 SUB #4 <- #0
DO ,1 SUB #5 <- #64
DO ,1 SUB #6 <- #194
PLEASE DO ,1 SUB #7 <- #48
DO ,1 SUB #8 <- #26
DO ,1 SUB #9 <- #244
PLEASE DO ,1 SUB #10 <- #168
DO ,1 SUB #11 <- #24
DO ,1 SUB #12 <- #16
DO ,1 SUB #13 <- #162
PLEASE READ OUT ,1
PLEASE GIVE UP

2. EMOJICODE

If you've ever imagined coding in emojis, then Emojicode is for you! Emojicode is a Turing complete Esolang consisting of emojis that was designed by Theo B. Weidmann. He came up with the idea after receiving texts with lots of emojis and his mind automatically started interpreting them as codes. This language uses C-style syntax for coding, but with emojis as functions.

To create an Emojicode source file, you use the file extension .🍇 or .emojic



🏁🍇

🍉

This is the basic structure of every Emojicode. The 🏁 is the special keyword[key-emoji] every program written in this language must start with. Every block of code must start with 🍇 and end with the 🍉.

Hello World in Emojicode



🏁 🍇
  😀 🔤Hello World!🔤❗️
🍉

A string in Emojicode is defined as the characters positioned between any two instances of the emoji 🔤. To illustrate, we invoke the print function using the grinning face with big eyes emoji 😀, passing the identified string as an argument. The ❗️ denotes the termination of the list of arguments supplied to the print function.

3. Whenever

Whenever lacks control flow—the aspect of every programming language that makes your code run in a systematic and well-structured order. This absence results in the language executing any part of the code whenever it wants, not in the order specified by the programmer. Whenever does not just lack control flow; it also lacks variables and data structures, which makes it impossible for Whenever to be used in mainstream programming.'

Hello World in Whenever

To write 'hello world' in Whenever is done similarly to Python, with the only difference being the mandatory inclusion of a line number and a semicolon.



1 print("Hello, World!");

If we decide to write 1 print('hello'); and 2 print('World') on different lines, we will sometimes get 'Hello World' outputted to the console or 'World Hello' at other times.

4. WHITESPACE

Unlike most programming languages that assign little or no meaning to whitespace characters, the only recognizable characters in Whitespace are the whitespace characters—tab, space, and line feed; anything else is ignored by the language. For this very reason, a Whitespace program looks like nothing but whitespace until you highlight the characters in the document.

The language was released on April 1, 2003, as an April Fool's joke by Chris Morris, and it is not intended to be used for mainstream programming. Obviously, who would want to use a John Cena form of programming language?

Hello World in Whitespace

5. BrainFuck

Brainfuck is not merely the name of a programming language; it also characterizes your mental state following your initial encounter with this unique language. Brainfuck exclusively acknowledges eight characters: < > [ ] , . + -. Anything outside these recognized characters in the code is treated as a comment.

Urban Müller developed Brainfuck in 1993 with the goal of creating the smallest-ever programming language compiler, measuring only 296 bytes. This endeavor followed Wouter van Oortmerssen's creation of the False language, which had a compiler size of 1024 bytes.

Hello World in BrainFuck



>++++++++[<+++++++++>-]<.

>++++[<+++++++>-]<+.

+++++++..

+++.

>>++++++[<+++++++>-]<++.

------------.

>++++++[<+++++++++>-]<+.

<.

+++.

------.

--------.

>>>++++[<++++++++>-]<+.

Conclusion

Esolangs represent the unconventional form of programming that decides to deviate from the rules of the programming dimension. They are not meant for mainstream coding but just to push the boundaries of the programming field.

As we delve into esolangs, you begin to appreciate the importance of mainstream languages that make our everyday coding efficient and effective.

Hey Devs, g.elvis🚀 here and its peace out.✌

Programming Languages Every Developer Should Watch Out For

Gyau Boahen Elvis — Mon, 02 Oct 2023 18:31:44 +0000

In the ever-changing field of programming, staying updated with the trends of new programming languages, frameworks, and other required tools is a necessity for every developer who seeks to thrive in this field. Remember Ada and COBOL? These were two dominant languages in the '90s, but today? Not so much. TypeScript was released in 2012, and it is a requirement for most full-stack developer jobs out there today. Dart first appeared in 2011 and has become a global phenomenon in the field of mobile app development. These are a few examples to illustrate how dynamic the field of computer programming is. New programming languages are released all the time, and it's better to stay updated and have a good knowledge of them now before they become a requirement for every job opportunity out there.

In this article, we will be looking at some of these "new" programming languages that every developer should keep an eye on, to keep it simple, we will be giving you reasons why you should care and to top it off, we will write "Hello, World" in each of them.

So buckle up, and let's dive in because it's going to be an exciting journey 🚀.

1. Carbon

Imagine if C++ is easy to read, write, understand, and had a smooth learning curve. It would be every developer's number one choice when it comes to building performance-critical applications. However, it's evident that C++ is not.

There are other programming languages out there, like Rust, that have relatively simple syntax and can be used to build performance-critical applications. The problem, though, is that these languages are not interoperable with C++. C++ has been used to build numerous applications across various industries, and no developer wants to undertake the daunting task of converting an entire C++ codebase to a different programming language.

This is the problem that Carbon seeks to solve. Carbon was first announced by Google in 2022 and is meant to be the successor to C++. Carbon is C++ interoperable, with a simple syntax, while also providing the performance of C++. The language is still a work in progress, and the official release date for Carbon 1.0 is set for either 2024 or 2025. Want to

Hello World Program in Carbon

fn Main() -> i32 {
 var s: auto = "Hello, World!";
 Print(s); 
 return 0; 
}

Similar to C++, every program begins with a main function, serving as the entry point. It's declared using the fn keyword, and specifying i32 indicates that the program will return a 32-bit integer.

To declare a variable, we utilize the var keyword and place a colon before the variable's identifier to specify its type. In this particular case, we've assigned the type auto to our variable, indicating that its type will be determined based on its initializer. The Print keyword is employed to display the value of s on the screen.

2. Rust

Rust is used in building systems where performance is critical, such as game engines, databases and operating systems. It is an excellent choice for WebAssembly. It offers relatively simple syntax and delivers with the speed of languages like C and C++.

Traditionally, high-level languages like Python use garbage collection for automatic memory management, while low-level languages like C++ provide functions like new, delete, and free to allocate and release memory spaces when needed. However, Rust takes a different approach, using the concepts of borrowing and ownership to ensure memory safety and proper management.

By default, all variables in Rust are immutable, meaning that attempting to assign a different value to a variable after it has already been given one will result in a compilation error. Instead of multiple variables, values are assigned to a single variable called the owner. When the program goes out of the scope of the owner, the memory space assigned to the variable is released using a special function known as drop in Rust.

Rust includes a standard library that provides various functionalities such multithreading, file systems, and input and output operations, among others.

It's also accompanied by a package manager and build tool called Rust Cargo. You don't have to concern yourself with programming dependencies and setups; all you need to do is specify the library, and Cargo will take care of the rest.

fn main() {
    println!("Hello, World!");
}

main() function is the entry point to the program, and it is declared using the fn keyword. println is used to display "Hello, World!" to the console. The ! in front of the println indicates it no regular function call but a macro in rust

3. Mojo

While Python is an excellent choice for productive programming, it does tend to lag behind other languages such as C++ and Rust when it comes to raw performance. This is where Mojo enters the scene, it's a superset of Python, and it boasts the remarkable ability to accelerate your code to speeds up to 35,000 times faster than standard Python.

Mojo, released in May 2023, comes from Modular, a company founded by the creator of Swift, which, replaced Objective-C. What sets Mojo apart is its full compatibility with Python, meaning you can still use your favorite python libraries with Mojo

Mojo also enhances Python with strong type checking, which can optimize your code. Dynamic programming, just like in Python, remains fully supported in Mojo.
Just like Rust, Mojo uses the concept of Ownership and Borrowing for memory safety and management. Just like python—Mojo is designed with a focus on programming for AI hardware GPUs. It comes equipped with built-in auto-tuning capabilities to optimize your code specifically for your target device.

Mojo truly unlocks a world of possibilities in high-performance computing.

Hello World Program in Mojo

fn main():
   print("Hello, world!")

This is so simple and requires no explanation. Enjoy 🚀

4. Elixir

Elixir is a dynamic and general purpose functional programming language with a straightforward syntax, similar to Ruby. It was released in 2012 by Jose Valim. Elixir runs on the Beam Erlang virtual machine, making applications created with Elixir very concurrent, resilient at runtime, and fault-tolerant—qualities that many applications built with programming languages like Python and Ruby often lack. Elixir consistently ranks among the most beloved languages by developers with a growing ecosystem, characterized by a welcoming community eager to share resources and valuable libraries with beginners.

These capabilities and Elixir tooling enable developers to be productive across a wide range of industries in fields such as web development, embedded software, machine learning, data pipelines, and multimedia processing.

It is used by discord to handle a massive amount of concurrent users. It is also used by Pinterest, Heroku and other notable applications.

Elixir comes with the Phoenix web framework, which offers most of what you need for web development tasks. It provides features that help developers easily keep track of multiple users connected to their applications. The LiveView feature of Phoenix makes it much easier for developers to build rich and interactive user interfaces without having to introduce a separate frontend tool to handle interactivity.
With simple syntax but efficient and concurrent performance, Elixir will take over the programming industry in no time.

Hello World Program in Elixir

IO.puts("Hello world from Elixir")

IO.puts just like in Ruby, is the responsible for displaying the "Hello world from Elixir" to the console. The parenthesis is optional in writing this program.

Conclusion

Hey Devs, In this field, just like you already know, you never stop learning; you have to gain the required knowledge the programming market expects you to, and it is quite a dynamic market. I hope this article gives you a fair idea of how the programming market will be in the years to come.

g.elvis here and Peace Out✌️

A Comprehensive Guide to APIs and the Fetch API

Gyau Boahen Elvis — Fri, 08 Sep 2023 20:29:15 +0000

Introduction

Have you ever wondered how Shazam instantly recognizes a song once a snippet is sent to it?🤔 How about, how Facebook automatically display your Instagram photos? The concept behind these amazing technological feats is not about your device storing every song or image in the world, but rather the fascinating concept of APIs (Application Programming Interfaces).

In this article, we will embarking on a journey to explore the inner workings of APIs, understand their various architectural types, and appreciate why mastering them is a neccessity in the world of software development. We'll specifically dive into the Fetch API, a JavaScript method that acts as a bridge between your applications and external servers, enabling seamless communication.

Buckle up and lets dig deep into this amazing concept together.

What are APIs?

According to IBM, An API, or Application Programming Interface, is a set of defined rules that enable different applications to communicate with each other. It acts as an intermediary layer that processes data transfers between systems, letting companies open their application data and functionality to external third-party developers, business partners, and internal departments within their companies.

The API is just the waiter that sends your order to the chef and then gets the food for you when it is ready. In this scenario, we are assuming that the chef is our server and you, the one making the order: the client. The waiter acts as the API-(mediator) between the client and the server, allowing communication between these two parties.

Types of API Architectures

APIs are categorized according to the set of protocols they follow, which govern the allowed data formats and commands. Significant APIs among these classes are stated below:

1. REST API
Representational State Transfer API is the most popular and widely used API today. It exchanges data using HTTP requests. This API follows the REST Guidelines, and a few of them are given below.

Client Server Interaction: Client-server interaction should take the form of a request from the client and a response from the server. The server is never allowed to make a request, and the client, never allowed to make responses.
Uniform Interface: To ensure interoperability between any client and any server, all requests must use HTTP as the communication format. All server responses must be in JavaScript Object Notation format.
Stateless: The interaction between a server and a client is distinct from all other interactions. Servers don't store any data from past interactions.

2. SOAP: These APIs employ the Simple Object Access Protocol to send data across a network. It uses XML to encode data across the network. It specifies exactly how data should be shared across a network. When compared to REST APIs, this makes it very safe for data exchange. Because of its rigorous constraints, this API is more difficult to implement and thus less popular among developers. It is usually used for internal data sharing, which necessitates a high level of security. The Amazon Web Services API is an example of a SOAP API.

3. GraphQL: Graph Query Language empowers clients to request only data they require, making it easier to evolve APIs over time and enabling strong developer tools. Given that we're using GitHub's API, you could use GraphQL to get only usernames or repository descriptions without receiving additional data apart from the ones requested. These APIs are efficient and boost application performance.

Why Master APIs

Over 10,000 APIs were made available for public use by businesses in 2013, which is four times more than there were in 2010. You can probably guess how many APIs are currently available.
With so many companies making investment in APIs, possessing a deeper understanding of API becomes a necessity in the software industry.

API is an essential part of the world we live in today. They are used everywhere on the internet, from using them to perform simple activities such logging in or signing up to your account with third party applications such as Google or Apple to integrating payment systems like PayPal or messaging systems into your applications as a developer. They also form the backbone of complex applications such as Spotify, Netflix and X (Twitter) among others.

The Fetch API

Fetch API is used to fetch resources over a network. It is the JavaScript method that is used to make requests to servers. It provides a flexible interface, making it very easier for our applications to communicate with servers.

How does the fetch API work?
The fetch API is a promised based method, that is: anytime we use the fetch API it returns a Promise object.

This Promise Object is more like a real-life promise in where we commit to doing something and, as a result, make a promise; in the end, it is either the promise we made is fulfilled and resolved or it is failed and rejected. This is exactly how JavaScript Promises work, too.

The Promise Object has three states:
🔃 The pending state: Promise is neither Fulfilled nor rejected
✅ The Fulfilled: Operation successfully carried out
❌ The rejected state: Operation failed.

The Promise Object comes with two hidden properties: value and onFulfilment array. The value property keeps the response object from the server, and the onFulfilment array stores the function(s) we wish to call after receiving the response object. These functions are added to onFulfilment array using the .then() method and are called immediately as soon as the valueproperty gets updated.

No need to worry about the value and onFulfilment array properties, since you won't ever use them.

Implementing the Fetch API



fetch(URL, optional)

The fetch API takes two arguments. The first argument is the URL to the resource we want to fetch - this is a compulsory.



fetch('https://www.example.com')

The second argument is optional, and it contains additional information we want to add to the URL. The additional information include

Methods: This tells the server the action the client wants to perform. They include

GET - Retrieve resource from server. This is the default method if no method is stated.
POST - Ask server to create new resource
PUT - Update resource on server
DELETE - Delete resource on server



fetch('https://www.example.com',{
     method:'post'
})

Headers: This provides meta information about the user's request. This includes the time of request, size of request, content-type among others.



fetch('https://www.example.com',{
     method:'post',
     headers:{
         "Content-Type": "application/json"
     }
})

Body: This where data the client wants to send to the server is included. Unlike the headers and methods with strict rules on how to include them, in the body the user is at complete liberty to include whatever they want.



fetch('https://www.example.com',{
     method:'post',
     headers:{
         "Content-Type": "application/json"
     },
     body:{
        "userName":"Gyau"
     }
})

The server returns a response which is then resolved to the response object. This object comes with several properties which could be used to check the status of the response from the server. Some of these properties include the ok property which will have a value of true if the request was successful, the status property which holds the HTTP Status response code of the response.

The catch() method holds the function to be called when the promise is rejected.



fetch('https://www.example.com',{
     method:'post',
     headers:{
         "Content-Type": "application/json"
     },
     body:{
        "userName":"Gyau"
     }
})

.then(response =>{
      if(response.ok){
         // Handling response
       }else{
        // Do something else
       }

   }
)
.catch(error=>{
        // function to run when promise is rejected
  }
)

Example

In the code snippet below, we are making an API GET to the Random User API, this API helps generate random users for testing your application.



fetch("https://randomuser.me/api/")

The then() method in the code snippet below uses the .ok property to determine whether the request was successful. If it was not, it throws an error; however, if it was, it uses the .json() method on the Response object to parse the response body as JSON.



fetch("https://randomuser.me/api/")
.then(response=>{

     if(!response.ok){
        throw new Error("Failed")
     }
        return response.json()
})

.then(data => console.log(data))

.catch(error => alert(error))

The JSON body of the response object is passed as an argument to the next .then() method. Then it is processed as specified in the function body. In the code above, we just console log the data to the console.

During the fetch or the processing of the response from the fetch API, if any error occurs, it is passed to the .catch() to handle the error.

Conclusion

API is an essential part of the software engineering industry, and possessing a deeper understanding of what it is and how to use the fetch API to integrate and sync systems together is a necessity in this field. I hope this article gives you a proper introduction to the concept of APIs and the fetch API. A tutorial by freeCodeCamp has been linked at the bottom of this article for further studies.

Happy coding out there, guys. Peace Out✌️

A Beginners Guide: Polymorphism, Virtual Functions, and Abstract Classes With C++

Gyau Boahen Elvis — Wed, 09 Aug 2023 11:15:26 +0000

Polymorphism

Polymorphism comes from two words: Poly which means many and Morph which means form. Polymorphism as a word simply means many forms. In Objected Oriented Programming, Polymorphism refers to a function or an object behaving in different forms.

Using a woman as an example, she could be a wife to one person, a mother to another, a friend to another, and a relative to another. The same woman, yet her job varies from person to person.

This is the idea polymorphism seeks to replicate in Objected Oriented Programming. Polymorphism gives us the ability to use the same expression to denote different operations.

Types of Polymorphism include run-time polymorphism and compile time polymorphism. Compile time polymorphism is achieved through function overloading or operator overloading, while run-time polymorphism is achieved through virtual functions.

Function Overloading

By using function overloading, we can have two functions that share the same name but carry out different operations. Below is an illustration:



class Shape{
private:
  double length, width;
public:
  double area(double l,double w){
   //Finds the area by taking just two argument eg: Rectangles
  }
  double area(double l){
   //Finds the area by taking just one argument eg: Square
  }
};

In the above code snippet, the Shape class has two area functions. The area function computes the area of a shape and returns its result. The first area function receives one argument, while the second takes two. The same function, but when given two arguments, it does something different from when given one. Isn't that incredible😁?

Virtual Functions

Given, we have the class PetType. This class defines a constructor that initializes the name member variable under the private access specifier. This class also declares the print function that prints out the name member variable. The implementation of this class is given below.



#include <iostream>
using namespace std;

class PetType{
    private:
    string name;

    public:
    PetType(string name="");
    void print()const;
};

void PetType::print()const{
    cout<<name<<endl;
}
PetType::PetType(string name){
    this->name=name;
}

Using the above codes as base class, we can derive the dogType class from our base class. This class also has a constructor which initializes breed and the name member variables of this derived class.



class dogType:public PetType{

    private:
    string breed;

    public:
    void print()const;
    dogType(string name = "", string breed="");

};

Note that the name variable of our base class is under the private member access specifier, and this implies that the derived class does not have a direct to this variable. In order to have access to this variable we have to do that through the public functions that were defined above, this is because our derived class has direct access to these functions.



void dogType::print() const{
    PetType::print();
    cout<<breed<<endl;
};

dogType::dogType(string name, string breed):PetType(name){
    this->breed=breed;
};

In the print function of our derived class, since we don't have direct access to the name variable then we can't directly print out the name variable print function, so to print out the name variable we have to call the print() of our base class.



cout <<name; //error in the print()

We don't have access to the name variable in the constructor of our derived class too, and hence the reason behind the code above.

**Note: **We can solve the problem of not having direct access to the name variable of our base class in the derived class by changing the private specifier to protected.



    // Slight modification in the base class
    protected:
    string name;

With the above modification: We are at complete liberty to make the modifications below without encountering an error during runtime of our program.



// Modifications in the function definition of the dogType class.
void dogType::print() const{
    cout<<name<<endl;
    cout<<breed<<endl;
};

dogType::dogType(string name, string breed){
    this->name=name;
    this->breed=breed;
};

Given that, we have the function below that takes in an object of the class PetType as an argument and then calls the print method(function) of the object.



void callPrint(PetType& p){
    p.print();
}

In our main function



1 int main()
2 {
3   PetType pet("Lucky"); //Lin
4   dogType dog("Tommy", "German Shepherd");
5   pet.print();
6   cout << endl;
7   dog.print();
8   cout << "*** Calling the function callPrint ***"<< endl;
9   callPrint(pet);
10  cout << endl;
11  callPrint(dog);
12  cout << endl;
13  return 0;
}

The result of running our program:

Now you may think the output of line 7 and line 11 of the codes in the main function may run to give us the same output. From the output of running the program you realize line 7 prints out Tommy on one line and German Shepherd on another line but line 11 prints out just Tommy.

To explain why this happens: remember, our derived class has 2 print() functions; the one it inherits from the base class and the other that print() that is written in the derived class. Remember in the definition of the callPrint function the parameter type that was assigned to p was of the class PetType and as such the compiler calls the PetType::print() on line 11.

This is a possible bug that we seek to resolve in C++ in the sense that we want line 11 to have the same output as line 7 and this because the print function related to the dogType class should print out both the breed and the name variables.

In the definition of the print function in the base class, we could prefix that the declaration with the virtual keyword.

By marking a function as "virtual," you indicate to the compiler that the function should be dynamically bound at runtime, which means the correct implementation of the function will be determined based on the actual object type.



//Modification In the PetType class
virtual void print()const;

With this slight modification in the base class, our output becomes

Importance of Virtual Function

Virtual functions are important because they enable you to write more flexible and extensible code. They allow you to design base classes with certain behaviors while leaving the specific implementation details to derived classes. This promotes code reusability and modularity, as well as simplifies the management of objects with varying behaviors.
When a function is prefixed with the virtual keyword, the compiler is instructed to decide the function's behavior based on the object type of the function rather than just the pointer or reference pointing to the function.

Abstract Classes / Pure Virtual Functions

Assume we have a shape class with a draw function that draws the shape. This function's implementation is shown below.



class Shape{
public:
 virtual void draw();
 //Function to draw the shape.

}

The shape class serves as the base class for other derived classes such as Rectangle and Oval among others.



class Rectangle:public Shape{
public:
 void draw();
 //Function to draw the rectangle.
}

class Oval:public Shape{
public:
 void draw();
 //Function to draw the oval.
}

Because the definitions of the draw function is more specific to a particular shape, each derived class can provide an appropriate definition of these functions.

The definition of the base class which is the Shape class requires that we write the definition of the draw function in the base class, but at this point which is in the base class there is no shape to draw. As a result, the draw function of our base class must have no code. How do we resolve this?

You may have guessed it right, that is, we define the virtual class as stated below:



void Shape:: draw(){
};

There is a disadvantage to defining the function like stated above. In the code above, since we have provided a definition to the draw function of the Shape class, we give users of the class the liberty to create objects of the Shape class and call the draw function on the object when the draw function does nothing.

In order to prevent this, C++ gives us abstract classes or Pure Virtual Functions.

To make a function a pure virtual function, we declare it as a virtual function and then use the assignment operator to assign the function's declaration to 0.



class Shape{
public:
 virtual void draw() = 0;
 //Function to draw the shape.
}

Since this function has no definition but it just an abstract class, C++ does not allow objects of this class to be created, but we can create a pointer from the base class that will point to the derived class.



Shape s1;//errror
Shape *s2; // No error

Conclusion

Polymorphism is an important concept of object-oriented programming. It simply means more than one form. That is, the same entity (function or operator) behaves differently in different scenarios.
To make a function virtual, we prefix the function declaration in our base class with the virtual keyword.



// In our base class
virtual void print()const;
//Assuming there is a print function in our base class

Given that the definitions of some functions in the base class are more specific to the derived class, and we want to make that function a pure virtual function, all we need to do is set the function's declaration to 0.



// In our base class
virtual void print()const = 0;

Hey guys😊 Elvis here, Don't forget to ask all your questions in the comment section right below. Like and share this please🥲.

Happy Coding out there

Mastering Background Image Darkening with CSS: Simple Yet Effective Techniques

Gyau Boahen Elvis — Thu, 27 Jul 2023 17:52:43 +0000

Upon scrolling through amazing landing page designs on Behance I found myself googling how to darken background images with CSS because I wanted to build a page like the one below.

I went through a few posts on Stack overflow and the answers were so overwhelming. I then decided to ask ChatGPT how I would darken my background image with CSS. The answers Stack Overflow suggested were not so different from what ChatGPT's answers. Both suggested I use an overlay then apply the background-color property to the overlay and set it to rgba(0,0,0,0.7). They also suggested I use the filter property which ended up reducing the brightness of the text on the page too. Another suggestion was that I use before or after pseudo-elements.

As a beginner who is not so comfortable with these concepts, I decided to read on the various background image and background color properties on Mozilla Developer Network and found the two-line secret to darkening background images.

But before that let's go through using the various concepts suggested by ChatGPT and Stack overflow to darken our background image.
Throughout this article this the HTML codes we will be using

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <main>
        <div class="text">Lorem ipsum dolor sit amet consectetur adipisicing elit. Ullam, laudantium.</div>
    </main>
</body>
</html>

A few CSS Styling to make our work look nice

body{
    padding: 0;
    margin: 0;
    box-sizing: border-box;
}
main{
    width: 100vw;
    height: 100vh;
    background-image: url("./img/workspace-gdfb557ae9_1280.jpg");
    background-position: center;
    background-repeat: no-repeat;
    background-size: cover;
    display: flex;
    justify-content: center;
    align-items: center;
}
main .text{
    color: #fff;
    font-size: xx-large;
}

This the link to the background image we will be using in this article here

1. Using the FILTER CSS Property

Let's add this piece of code to our CSS styling we have above.

main{
    filter: brightness(50%);
    -webkit-filter: brightness(50%);
}

This is one of the easiest techniques of darkening your background image. The only disadvantage to this technique is that it reduces the legibility of the text on your page.

2. Using the ::before pseudo-elements

main{
    position: relative;
}
main::before{
    content: "";
    width:100vw;
    height: 100vh;
    background-color: rgba(0, 0, 0, 0.7);
    position: absolute;
}
main .text{
    position: relative;
    z-index: 20;
}

For just darkening your background image while making sure the texts on the page are legible, this just too much from my point of view and probably every beginner's point of view. It contains so many concepts that may be difficult for beginners to grasp.

3. Using the background-blend-mode CSS Property

main{
    background-color: rgba(0, 0, 0, 0.7);
    background-blend-mode: darken; 
}

This the simplest and the most effective way of darkening your background image while making sure your texts on your page are legible.

Conclusion

There are several methods to darken a background image using CSS, but the most effective and beginner-friendly approach is by using the background-blend-mode property with the value of darken. This method allows you to darken the background image without affecting the text's legibility on the page.

Here's the final CSS code using the background-blend-mode property:

main {
  width: 100vw;
  height: 100vh;
  background-image: url("./img/workspace-gdfb557ae9_1280.jpg");
  background-position: center;
  background-repeat: no-repeat;
  background-size: cover;
  display: flex;
  justify-content: center;
  align-items: center;
  background-color: rgba(0, 0, 0, 0.7);
  background-blend-mode: darken;
}
main .text {
  color: #fff;
  font-size: xx-large;
}