PolyLoopis in the Enterprise Collaboration Industry

PolyLoop

polyloop

A Practical Guide to Dynamic Polymorphism in C Programming

Understanding Dynamic Polymorphism in C++ Dynamic polymorphism is a fundamental principle in object-oriented programming, allowing objects to be treated uniformly while exhibiting different behaviors. This feature is crucial for achieving flexibility and reusability in software design. In this article, we'll explore dynamic polymorphism with a sample program, explain heap and stack memory, delve into the virtual table (vtable), and discuss memory consumption details. Achieving Dynamic Polymorphism in C++ To demonstrate dynamic polymorphism, consider the following example in C++: #include <iostream>

// Base class
class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Animal sound" << std::endl;
    }
    virtual ~Animal() = default; // Virtual destructor
};

// Derived class
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof" << std::endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // Outputs: Woof
    animal2->makeSound(); // Outputs: Meow

    return 0;
} In this example, Animal is the base class with a virtual method makeSound(). The Dog and Cat classes override this method. At runtime, the appropriate method is called based on the actual object type (Dog or Cat), demonstrating dynamic polymorphism. C Variant To understand how this is achieved in C, let's recreate the same program: #include <stdio.h>
#include <stdlib.h>

char const* dogSound(void){return "Woof!";}
char const* catSound(void){return "Meow!";}

typedef struct Animal{
    char const * (*makeSound)(); //function pointer
}Animal;

void makeSound(Animal * self){
    printf("%s\n",self->makeSound());
}

Animal * constructDog(){
    Animal * dog = malloc(sizeof(Animal));
    dog->makeSound = dogSound;
    return dog;
}

Animal * constructCat(){
    Animal * cat = malloc(sizeof(Animal));
    cat->makeSound = catSound;
    return cat;
}

int main(void){
    Animal * cat = constructCat(); 
    Animal * dog = constructDog();

    makeSound(cat); // Outputs: Woof
    makeSound(dog); // Outputs: Meow
    return 0;
} Here, function pointers are used to achieve polymorphism in C. The Animal struct contains a function pointer makeSound, which is assigned appropriate functions (dogSound or catSound) at runtime. Heap and Stack Explanation In the sample program, objects animal1 and animal2 are created using the new keyword. This means they are allocated on the heap, which is a region of memory used for dynamic memory allocation. The delete keyword is used to deallocate memory, preventing memory leaks. Conversely, if we had created objects without the new keyword (i.e., Dog dog;), they would be allocated on the stack. The stack is used for static memory allocation, which is automatically managed and has a smaller, faster access compared to the heap. Vtable (Virtual Table) The vtable (virtual table) is a mechanism used by C++ to support dynamic polymorphism. It is a table of function pointers maintained per class. Each class with virtual functions has a corresponding vtable, and each object has a pointer to this vtable, known as the vptr (virtual pointer). When a virtual function is called on an object, the compiler uses the vptr to look up the correct function in the vtable and invoke it. This lookup allows C++ to resolve the function call at runtime, enabling dynamic polymorphism. Memory Consumption Memory consumption in dynamic polymorphism involves both the heap (for dynamic allocation) and the memory overhead of maintaining vtables and vptrs. Each object with virtual functions contains an additional pointer (vptr), and each class with virtual functions has an associated vtable. While the heap allocation allows flexibility, it comes with a cost: dynamic memory management can lead to fragmentation, and improper deallocation can cause memory leaks. Additionally, the indirection through vtables can introduce a slight performance overhead due to the extra pointer dereference. Conclusion Dynamic polymorphism in C++ is a powerful feature that enables flexibility and reusability in object-oriented design. It is achieved through virtual functions, heap allocation, and the use of vtables. Understanding the memory implications and how the heap and stack work is essential for efficient programming in C++. By following best practices in memory management and being mindful of the costs associated with dynamic polymorphism, developers can harness their full potential to create robust and maintainable software. Understanding Dynamic Polymorphism in C++ Dynamic polymorphism is a fundamental principle in object-oriented programming, allowing objects to be treated uniformly while exhibiting different behaviors. This feature is crucial for achieving flexibility and reusability in software design. In this article, we'll explore dynamic polymorphism with a sample program, explain heap and stack memory, delve into the virtual table (vtable), and discuss memory consumption details. Achieving Dynamic Polymorphism in C++ To demonstrate dynamic polymorphism, consider the following example in C++ : C++ #include <iostream>

// Base class
class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Animal sound" << std::endl;
    }
    virtual ~Animal() = default; // Virtual destructor
};

// Derived class
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof" << std::endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // Outputs: Woof
    animal2->makeSound(); // Outputs: Meow

    return 0;
} #include <iostream>

// Base class
class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Animal sound" << std::endl;
    }
    virtual ~Animal() = default; // Virtual destructor
};

// Derived class
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof" << std::endl;
    }
};

// Another derived class
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound(); // Outputs: Woof
    animal2->makeSound(); // Outputs: Meow

    return 0;
} In this example, Animal is the base class with a virtual method makeSound() . The Dog and Cat classes override this method. At runtime, the appropriate method is called based on the actual object type ( Dog or Cat ), demonstrating dynamic polymorphism. Animal makeSound() Dog Cat Dog Cat C Variant C Variant To understand how this is achieved in C, let's recreate the same program: #include <stdio.h>
#include <stdlib.h>

char const* dogSound(void){return "Woof!";}
char const* catSound(void){return "Meow!";}

typedef struct Animal{
    char const * (*makeSound)(); //function pointer
}Animal;

void makeSound(Animal * self){
    printf("%s\n",self->makeSound());
}

Animal * constructDog(){
    Animal * dog = malloc(sizeof(Animal));
    dog->makeSound = dogSound;
    return dog;
}

Animal * constructCat(){
    Animal * cat = malloc(sizeof(Animal));
    cat->makeSound = catSound;
    return cat;
}

int main(void){
    Animal * cat = constructCat(); 
    Animal * dog = constructDog();

    makeSound(cat); // Outputs: Woof
    makeSound(dog); // Outputs: Meow
    return 0;
} #include <stdio.h>
#include <stdlib.h>

char const* dogSound(void){return "Woof!";}
char const* catSound(void){return "Meow!";}

typedef struct Animal{
    char const * (*makeSound)(); //function pointer
}Animal;

void makeSound(Animal * self){
    printf("%s\n",self->makeSound());
}

Animal * constructDog(){
    Animal * dog = malloc(sizeof(Animal));
    dog->makeSound = dogSound;
    return dog;
}

Animal * constructCat(){
    Animal * cat = malloc(sizeof(Animal));
    cat->makeSound = catSound;
    return cat;
}

int main(void){
    Animal * cat = constructCat(); 
    Animal * dog = constructDog();

    makeSound(cat); // Outputs: Woof
    makeSound(dog); // Outputs: Meow
    return 0;
} Here, function pointers are used to achieve polymorphism in C. The Animal struct contains a function pointer makeSound , which is assigned appropriate functions ( dogSound or catSound ) at runtime. Animal makeSound dogSound catSound Heap and Stack Explanation In the sample program, objects animal1 and animal2 are created using the new keyword. This means they are allocated on the heap, which is a region of memory used for dynamic memory allocation. The delete keyword is used to deallocate memory, preventing memory leaks. animal1 animal2 new delete Conversely, if we had created objects without the new keyword (i.e., Dog dog; ), they would be allocated on the stack. The stack is used for static memory allocation, which is automatically managed and has a smaller, faster access compared to the heap. new Dog dog; Vtable (Virtual Table) The vtable (virtual table) is a mechanism used by C++ to support dynamic polymorphism. It is a table of function pointers maintained per class. Each class with virtual functions has a corresponding vtable, and each object has a pointer to this vtable, known as the vptr (virtual pointer). When a virtual function is called on an object, the compiler uses the vptr to look up the correct function in the vtable and invoke it. This lookup allows C++ to resolve the function call at runtime, enabling dynamic polymorphism. Memory Consumption Memory consumption in dynamic polymorphism involves both the heap (for dynamic allocation) and the memory overhead of maintaining vtables and vptrs. Each object with virtual functions contains an additional pointer (vptr), and each class with virtual functions has an associated vtable. While the heap allocation allows flexibility, it comes with a cost: dynamic memory management can lead to fragmentation, and improper deallocation can cause memory leaks. Additionally, the indirection through vtables can introduce a slight performance overhead due to the extra pointer dereference. Conclusion Dynamic polymorphism in C++ is a powerful feature that enables flexibility and reusability in object-oriented design. It is achieved through virtual functions, heap allocation, and the use of vtables. Understanding the memory implications and how the heap and stack work is essential for efficient programming in C++. By following best practices in memory management and being mindful of the costs associated with dynamic polymorphism, developers can harness their full potential to create robust and maintainable software.

Understanding Dynamic Polymorphism in C++

Hello guys. In the and the , we learned about what is why we should use it, and saw examples of different principles. This is the last part of GRASP, where we will learn all other principles. first part second part GRASP, Polymorphism GRASP polymorphism as you may guess it’s an implementation OOP polymorphism principle. What is the difference between OOP polymorphism and GRASP polymorphism? OOP polymorphism says that we could use inheritors from one class from the place, where their parent could be used and at the same time they could do different polymorphic actions. GRASP polymorphism says, that using OOP polymorphism we can solve a specific task. What problem we can solve? Let’s check an example. Imagine that we use external API, for example, bank API in our system. At some point, they decided to switch to the second version, API 2, with supporting the first version? What we can do? For example: if (API === 1) {
// do1
// do2
} else if (API === 2) {
// do3
// do4
}

// do5
// do6

if (API === 1) {
// do7
// do8
} else if (API == 2) {
// do9
// do10
} And we can have the same conditions in different places, different files. And imaging after some time external API create next, the third version API 3 and we should switch to this version. What we should do? Go through all files, though all if/else (switch/case), and add a new condition. What the problem could be in this approach: We can forget about some places, where used these conditions (or we may not know about them) All old API versions most likely will be kept forever, no one will remove them If external API will be changed a lot, we will have a huge codebase, it will be really hard to maintain. What can we do to avoid it? We can use the polymorphism principle. Only at 1 place, do we create conditions (depends on ENV, CI, config…), and then we use, we use polymorphic functionality that uses the same interface throughout the whole application. And now, if we migrate to the new API version, we can easily remove 1 class with the old version and only 1 import where this class was used before. We don’t have a huge code base, we don’t need to remember many places where if/else could be, and our system is easy to maintain. So, OOP polymorphism and GRASP polymorphism is almost about the same, where OOP polymorphism says what we can do and where GRASP polymorphism, its implementation, it says what we can solve using OOP polymorphism. Pure Fabrication If we remember about OOP, is that objects in our code are objects from the real world. But sometimes we use objects, that are not exist in the real world, some abstractions (facade, mediator, proxy). Such not real objects are called pure fabrication. In general, pure fabrication it’s just a term for not real objects, nothing special. Indirection (Inversion of control or Dependency injection) It’s one of the most important patterns, that are used in many famous frameworks. One of the good things that we should remember, is that all communication with class should be used from the interface, not from class directly. Let’s see an example. In a common use case we have controller, service and API service (controller, entity, repository) For simplicity, we have class A, class B, and class C. Let’s think we work with user. So we have User controller, user entity and user repository that works with DB using Postgress. So, how do they depend on each other? A → B → C // User controller
import userService from './userService';

const body = req.body;
userService.create(user);

// User service
import userApi './userApi';

async function create(user) {
  // some code
  await userApi.create(user)
} And sometime later, a new engineer has a task to do something pretty the same as it is now, but use for specific case saving data not to Postgress, but to MongoDB. In our case, we can see that now we create our user in some DB. And what we will do when we need the same functionality but for another kind of DB? Probably we will create almost the same userApi class (file) for working with DB. But how we will use it? We have a couple of options (both of them are bad) We can add if/else in the current  userService file and use 2 kinds of DB We can copy/paste userService that works almost the same but uses another DB And if sometime later we decide to add more DBs? We should do the first or the second option for each of them? The correct way is to use not class directly, but use interface. In our case we can create an interface for the DB class: inteface IUserApi {
  getById(id: string): User
  create(body: UserCreateRequestDTO): User;
  deleteById(id: string): void;
} For each DB we can create a class (functions) that implements this interface. class UserService {
  userApi: IUserApi;
  constructor(userApi: IUserApi) {
    this.userApi = userApi;
  }

  getById(id: string) {
    return this.userApi.get(id)
  }
} And in our UserService we can create the ability, to decide what will be used with our service right now (using dependency injection or manually): // User Controller
class UserController() {
  constructor() {
    if (a) {
      this.userService = new UserService(userWithMongoDbApi)
    } else {
      this.userService = new UserService(userWithPostgressDbApi)
    }
  }
} And also for the UserController we can use the same teqniqe. So now, we don’t use DB classes directly in userService as it was before. Our userService work only with interface IUserApi and for userService doesn’t matter is it mongoDb, Postgress, MySql… Our dependency is not like A→B-C, but A-B→InterfaceApi So, when we need to add a new DB, we don’t need to duplicate the code or create if/else in each case, we just need to add a new interface implementation and only once setup what implementation class will be used. Protected Variations It’s a pretty simple pattern and it is a unifying principle from all previous GRASP patterns. This principle says: that we should create our system in a way, where we can change something in one place, all other code should work as before, it shouldn’t break the previous implementation. For example, A→B→C→D and we want to change from C to X, A→B-X-D our system should work. If we want to add something new or remove unused code, our system shouldn’t fail. How can we achieve it? We should follow all previous GRASP principles, that we’ve already discussed. Let’s remember them briefly: : this pattern says that all methods that work with data (variables, fields), should be in the same place where data (variables or fields) exist. Information expert says who and where should objects be created. Creator says, that in our system, we should create as fewer connections between our classes, modules, files, etc… as possible. Low coupling principle says, that if you have a class (object, file, etc…) all fields and methods should do only one well-defined job. The high cohesion says that we should work with other system parts using the interface, not directly. Inderection I really hope that you enjoyed all 3 parts of GRASP articles and if you haven’t known them before, now you can take 1, 2 or all of them and use in your project.

GRASP Principles - Part 3: Polymorphism, Pure Fabrication, Indirection, Protected Variations

PolygonPunks launches to become the world’s first “punks” NFT on the Polygon (Matic) network – following in the footsteps of the legendary Ethereum based NFT collection, CryptoPunks. The NFT craze is gaining massive momentum this year. The crypto world has witnessed NFT artwork selling for up to $69 million and there is no sign of the momentum stopping anytime soon. One of the newest NFT collections to hit the market are - which have quickly become one of the most popular & sought after NFTs on the Polygon (Matic) network.
PolygonPunks are a unique Non-Fungible Token (NFT) on the Polygon blockchain. PolygonPunks The entire collection of 10,000 punks were officially minted on August 3rd, 2021 via the website – solidifying their history as the 1st CryptoPunks on Polygon. PolygonPunks have clear intentions to be unique while simultaneously recognizing and giving homage to the original CryptoPunks NFT collection, whose floor price currently resides at $64,000. polygonpunks.io Each PolygonPunk has attributes that make them unique according to a defined rarity system. Once the PolygonPunks minting finished, a buying frenzy ensued. In less than 24 hours the PolygonPunks emerged as the 2nd most popular collection on Opensea by volume. Fast forward a week and the PolygonPunks have over $500,000 in trading volume across all NFT marketplaces, which is 50%+ of the volume CryptoPunks had in 3 years. With Crypto Punks becoming unattainable due to their skyrocketing value, PolygonPunks present an alluring alternative. Not only is the price of PolygonPunks significantly lower, but they are built on Polygon - one of the most scalable, fast, and cost-efficient networks ever built. The high trade volume of PolygonPunks was primarily achieved from the buying, selling, and trading on a truly decentralized NFT marketplace. PolygonPunks are now the #1 Traded NFT on the platform with $339,000+ in trade volume to date: NFTrade To celebrate the successful launch of PolygonPunks and help those in need, PolygonPunks donated 10% of all gross profits from minting to . Crypto Relief Crypto Relief is the result of the global crypto community mobilizing to help India combat the COVID19 crisis, and to help it prepare for future outbreaks. The fund was started by Sandeep Nailwal (co-founder of Polygon) and has since been supported by Vitalik Buterin (co-founder, Ethereum) and Balaji S. Srinivasan (former CTO at Coinbase). All the PolygonPunks are visible on the interface and will also be exchangeable on a proprietary NFT marketplace. You can collect as many PolygonPunks as you want but there are only 10,000 in existence and there will never be any more. The minting may be finished but the trading has just begun. Don’t miss out on your chance to own a part of the PolygonPunks legacy! Polygonpunks.io Originally published on Yahoo Finance

Introducing PolygonPunks: The First 'Punks' on the Polygon (Matic) Network

Brief Introduction To understand Rails Polymorphic Association, let us refresh our minds on Rails Active Record. What is Rails Active Record? Rails Active Record is the M in the MVC architecture framework. The model which is the layer of the system responsible for representing business logic and data. Active Record facilitates the creation and use of business objects whose data requires persistent storage to a database. It is an implementation of the Active Record Pattern which itself is a description of an Object Relational Mapping System. Polymorphic Association is an Active Record Association that can connect a model to multiple other models. For example; we can use a single association to connect a Post model with Comment and Like models, allowing us to query the Post model. Let get on with the code, first, we create a rails app rails post_app new This command will generate the basic files we need. Now we will generate 3 models as seen in the diagram above. Steps in creating our model are described below: rails g model Post : : like_id: comment_id: content string image string integer integer This command will create a migration file for the post with the specified columns. rails g model : Comment content string This command creates a migration file for the comment with the specified column => content, rails will add a default id for every model, in this case, rails will generate a comment_id rails g model Like : content string Now, it is time we add our associations to our model. post.rb ApplicationRecord & ; class Like lt has_many :comments<br>has_many :likes end comment.rb ApplicationRecord & ; class Comment lt :post belongs_to end like.rb ApplicationRecord & ; class Like lt :post belongs_to end So now, we have all our model and polymorphic association setup. The next step is to migrate our migration files with the command below rails db :migrate This command will create a schema.rb file in our db/schema.rb where we have all our 3 tables setup Now, we can test our association with the help of the rails console. Type rails c To open the rails console. Now we can create post with the following command p1 = Post.create( , ) content: 'my first post' image: 'free.png' This command will create and save a post in the variable p1. When we type p1, we should have the details of the post &lt;Post , , &gt; id: 1 content: 'my first post' image: 'free.png' Now let us create our comment by assigning our first comment to a variable = Comment.create(content: ) c1 'the post is awesome' This command will throw an error because the comment is associated with the post, so in order to fix this. Let check the command below c1 = Comment.create( , ) content: 'the post is awesome' post_id: 1 With the post_id as the argument, the comment is now created successfully. Now let us create 1 like as we did with the comment. l1 = . (content: Like new 'i like the post', post_id: 1) This command will create the like without saving it, so we need to save it with the command l1 .save This is why I like using the ‘create’ method in this article. Now we can play around the models and associations in the console. For more information and details explanation, let us visit the rails documentation https://guides.rubyonrails.org/active_record_basics.html If you like this article - share it with friends. Thank you for reading. My next article will be about Javascript Async and Await. Until then have a great coding day Github: https://github.com/addod19 Twitter: https://twitter.com/DanielLarbiAdd1 AngelList: https://angel.co/u/daniel-larbi-addo LinkedIn: https://www.linkedin.com/in/daniel-larbi-addo/

Understanding Rails Polymorphic Active Record Associations

Inheritance is one of the most used method for code reuse. Object Oriented Languages strive on the inheritance to collect the common functionality in a base class. What is Polymorphism? From : stackoverflow If you think about the Greek roots of the term, it should become obvious. Poly = many: polygon = many-sided, polystyrene = many styrenes (a), polyglot = many languages, and so on.Morph = change or form: morphology = study of biological form, Morpheus = the Greek god of dreams able to take any form. So polymorphism is the ability (in programming) to present the same interface for differing underlying forms (data types). Polymorphism in C++ C++ support both Dynamic and Static Polymorphism. In this type of polymorphism, the type of the object is not known at compile time ( maybe based on user input, etc), and thus compiler adds extra data structure to support this. The standard doesn't dictate on how it should be implemented. Dynamic Polymorphism : In this type, the type of the object is known at the compile time itself and hence there is no need to actually save extra information in the data structure. But as mentioned in before, we need to know the type of the object at compile time. Static Polymorphism : Static Polymorphism using the Curiously Recurring Template Pattern Since this article is about static polymorphism, we will brush aside all the discussion on dynamic polymorphism. Let's try to simulate calling different Binary Operators. In the grand-scheme of things this can be used when one wants their own Expression Template Library. Let's see a simple example code. < Derived> { <Derived*>( )->implementation(x, y);
  }
}; template typename { struct BinaryOperator float interface ( x, y) float float return static_cast this Here we have a base class template (note that this is not a class as it won't instantiated will the Derived Type is known) with the interface method which calls the implementation of the derived class. BinaryOperator BinaryOperator<Add>{ { :: << << :: ; x + y;
  }
}; BinaryOperator<Subtract>{ { :: << << :: ; x - y;
  }
}; : struct Add float implementation ( x, y) float float std cout "Implementation Add" std endl return : struct Subtract float implementation ( x, y) float float std cout "Implementation Sub" std endl return These are our derived classes for the . It is after looking at that the compiler generates a specialised base class for the and similarly for . BinaryOperator BinaryOperator<Add> Add Subtract So now if we create objects of our derived classes and hold a reference to them using our base class, we can call the interface. This call will dispatch to the implementation of derived class. { :: << :: ;
  
  BinaryOperator<Add>&& add = Add{};
  BinaryOperator<Subtract>&& subtract = Subtract{}; :: << add.interface( , ) << :: ; :: << subtract.interface( , ) << :: ; :: << :: ;
  
} int main () std cout std endl std cout 4 5 std endl std cout 4 5 std endl std cout std endl As expected the calls for add.interface will be dispatched to implementation and similarly for . Add's Subtract Implementation Add Implementation Sub 9 -1 Here is the whole code snippet. < Derived> { <Derived*>( )->implementation(x, y);
  }
}; BinaryOperator<Add>{ { :: << << :: ; x + y;
  }
}; BinaryOperator<Subtract>{ { :: << << :: ; x - y;
  }
}; { :: << :: ;
  BinaryOperator<Add>&& add = Add{};
  BinaryOperator<Subtract>&& subtract = Subtract{}; :: << add.interface( , ) << :: ; :: << subtract.interface( , ) << :: ; :: << :: ;
  
} # include <iostream> template typename { struct BinaryOperator float interface ( x, y) float float return static_cast this : struct Add float implementation ( x, y) float float std cout "Implementation Add" std endl return : struct Subtract float implementation ( x, y) float float std cout "Implementation Sub" std endl return int main () std cout std endl std cout 4 5 std endl std cout 4 5 std endl std cout std endl If one is not happy with explicitly working with floats, then we can also take the as template parameter. DataType < Derived, DataType> { <Derived*>( )->implementation(x, y);
  }
}; < DataType> BinaryOperator<Add<DataType>, DataType>{ { :: << << :: ; x + y;
  }
}; < DataType> BinaryOperator<Subtract<DataType>, DataType>{ { :: << << :: ; x - y;
  }
}; < DType, < > op(x, y);
} { DType = ; :: << :: ;

  DType x = ;
  DType y = ; :: << execute(Add<DType>{}, x, y) << :: ; :: << execute(Subtract<DType>{}, x, y) << :: ; :: << :: ;
  
} # include <iostream> template typename typename { struct BinaryOperator DataType operator () (DataType x, DataType y) return static_cast this template typename : struct Add DataType implementation (DataType x, DataType y) std cout "Implementation Add" std endl return template typename : struct Subtract DataType implementation (DataType x, DataType y) std cout "Implementation Sub" std endl return template typename template typename > ( <DType> , , ){ class Op DType execute Op op DType x DType y return int main () using double std cout std endl 4 5 std cout std endl std cout std endl std cout std endl Thanks for reading!

Static Polymorphism using Curiously Recurring Template Pattern (CRTP)

Discover the secrets of polymorphism, one pillar of Object-Oriented Programming As Web Developers you need to know that times and times again you are going to rewrite, update or delete some features on codes that you have deployed ages before. Once moved from the procedural paradigm and starting to learn the basics of Object-Oriented programming you will find out that the code has not only to be clean and scalable but it has to be manageable. and this worth for as well as other languages. PHP programming The scripts have to be so easy to work with that you won’t want to change job if your technical director asks you to refactor or add new characteristics. Some of the techniques used to write code that is reliable now as much as in the long-term are the use of interfaces and a clear understanding of polymorphism. If you missed it, Click here to understand what an interface is and to check the first build-in interfaces of the PHP language out. Otherwise, below you will find the second part of the list explaining PHP interfaces (you will not use them on daily basis but you must know that they exist and make them part of your swiss knife when needed). and a brief and clear explanation of the concept of polymorphism. Let get started. ArrayAccess This interface let objects being accessed as arrays. The main benefit of this behaviour is structural Object properties are usually well defined and of different types. If you implement ArrayAccess you tell to the script “ ”. My objects can also behave like arrays interface

    function

    {

    }

    function

    {

    }

    function

    {

    }

    function

    {

    }

} Serializable “To serialize” verb, . (Oxford Dictionaries). Arrange (something) in a series Sometime you may need a collection of data to be combined and ordered in a certain way. which is much easier to be transported and imported elsewhere. The Serializable interface allows you to transform your data in a formatted string interface

    function

    {

    }

    function

    {

    }

} Implement this interface on an object will mutate the format of the data, Let’s have a look at an example: $obj

$obj->data = "My private data";

$ser

var_dump($ser);

// the var_dump above will print: string(38) "C:3:"obj":23:{s:15:"My private data";}" In the next episode of this article, I will explain what magic methods are but for now, just keep in mind that: If a class implement this interface it will no longer support the __sleep() and the __wakeup() methods. Countable The reason to implement it in a class is to count. Seriously? interface

    function

    {

    }

} Within this function, you can count the number of objects,count the elements of an array or even just return a number. Countable on php.net OuterIterator We have already touched previously, Iterators PHP consent you to loop through several types of data: arrays, databases, object, directory structures, etc. Sometimes you what to iterate over another iterator that is iterating over something else. PHP has got you covered and it does it by using the OuterIterator interface. It has only one method getInnerIterator() and extend the Iterator interface Interface OuterIterator extends

    function

    {

    }

    // Methods inherited from Iterator

    function

    {

    }

    function

    {

    }

    function

    {

    }

    function

    {

    }

    function

    { 

    }

} The OuterIterator needs to extend Iterator which means you must implement all the methods that follow. OuterIterator on php.net RecursiveIterator This interface is very similar to the previous one. In fact, Class that implements RecursiveIterator simply iterates over iterators recursively It has two own methods and extends the Iterator interface as well. Interface RecursiveIterator extends

    function

    {

    }

    function

    {

    }

    // Methods inherited from Iterator

    function

    {

    }

    function

    {

    }

    function

    {

    }

    function

    {

    }

    function

    {

    }

} RecursiveIterator on php.net SeekableIterator This method allows you to investigate an Iterator, Interface SeekableIterator extends

    function

    {

    }

    // Methods inherited from Iterator

    function

    {

    }

    function

    {

    }

    function

    {

    }

    function

    {

    }

    function

    {

    }

} The method allow to seek to a position of the Iterator seek SeekableIterator on php.net SplObserver and SplSubject Both SplObserver and SplSubject are used alongside each other to implement the Observer Design Pattern Here is a video tutorial form Christopher Okhravi’s youtube channel Interface SplObserver {

    function

    {

    }

} SplObserver on php.net SplSubject on php.net Polymorphism Early on in this article, you discovered that in Object-Oriented Programming one of the fundamentals is the inheritance, Here is another of the pillar of OOP To simplify this very harsh word I can use the following sentence: If classes have different functionality but share a common interface here is where you see polymorphism. In a practical example polymorphism is writing the same code and giving it the same name but allowing it to take a slightly different type of argument variable or input and then output a slightly different result depending on these parameters. Interface Building

{

    function

    {

    }

}

class

{

    ...

    function

    {

    return

    }

}

class

{

    ...

    function

    {

    return

    }

}

function

    $interestRate

    return

}

$school

$office

echo

echo The example above illustrates in a simple way (at least I hope so) of how polymorphism works. We still have our beloved buildings, and we need to get their price. The complication stays in the fact that even though we need to calculate the same thing (in our case the price) the evaluation to find the price is calculated in two different ways. A school gets this valuation by the number of students plus the number of teachers that work in it. The office instead gets its evaluation from the number of computers within the building. By creating the building interface and declare it in the getPrice() function we can require a different type of building such as schools, office, and others without compromising security. The nice thing about polymorphism is that the code will work with the multiple classes and it does not need to know which class it is being used because they’re all used the same way. Polymorphism is mainly used to make applications modular. Instead of using conditional statements that create different actions, you create interchangeable objects that you select based on the needs of the moment. the principle of polymorphism is keeping your components separate and it does it very well. for this reason, you will find it in many design patterns, but this is a story for another time… Conclusion of the third part The full version of “The complete guide to Object-Oriented Programming” in an all-in-one edition is available in a Kindle format on Amazon anyway soon the following parts will be published. Here you have it, as I said there are plenty of built-in interfaces in PHP. Even if you rarely will use them it is good to know that they exist and when there will be the need of its use you will be able to use them. Same thing for polymorphism,It is a concept quite difficult to grasp at the beginning but once you understood the reason why it helps improve the quality of your code, you are going to want to master its implementations everywhere you see a leak in the program. Now it is your turn: Let me know it the comment below which interface it’s more useful for your and how do you want to insert it in your code? If you like this content and you are hungry for some more join the Facebook’s community in which we share info and news just like this one!

Introduction to Interfaces and Polymorphism

In our short look at polymorphism at work in both the Class Inheritance and Abstract Classes & Interfaces chapters, we got a glimpse at how powerful polymorphism is. In both chapters, we learned that any object that can pass more than one test, that is any object that is of more than one type, is considered polymorphic. With that said, we can define polymorphism as the ability of an object to take on more than one form. is-a Why is Polymorphism Important & Useful Polymorphism is one of the most important concepts in object oriented programming. It is what allows us to say that all types in Java are the type of its class as well as the type of the Object class; we’ve learned that all objects in Java are instances of the Object class because of Java’s class hierarchy. One Functionality for All We learned in the Class Inheritance chapter that If we can say an instance of a class can be of more than one type, we can build functionality for one class that works for any class that extends it. We created a Human class that our Warrior, Archer, and FireArcher all inherited from. That allowed us to create methods that accepted them all as parameters because we could group them all as being Human. That is polymorphism at work. One Collection for All Remember in the three Data Structures chapters that with any data structure, collection, we can only store elements of the same type: each element of a String array must be of type String and each element in a Human LinkedList must be of type Human. In the HashMaps chapter, we saw that if we don’t explicitly specify the type of our keys and values, Java implicitly sets the map to store keys of type Object and values also of type Object because every class in Java extends the Object class provided by Java. This is only legal because of polymorphism. Let’s revisit our Conquer game example from earlier to see how we can collect all our friends in the game in a single list. The classes of the different characters in the game will be omitted from this chapter, so make sure to open the supporting source code. Remember that we have a Character interface that every character class implements, an Human class that all human character class extends, and an abstract Pet class that all pet classes extend. We will focus on the Human class and its subclasses because while a user can have a pet, a user who plays our game can only be a human character. Let’s create a Human instance for ourself, , and a couple Human instances to represent other users: abstract currentUser _//the Human character representing the current user_Human currentUser = Archer( ); new "ModernNerd" _//other Human characters playing the game_Archer human2 = Archer( );Human human3 = FireArcher( );Warrior human4 = Warrior( );Taoist human5 = Taoist( ); new "Tom" new "Christina" new "Tyrone" new "Jerome" We are the currentUser Human instance which is also an Archer instance. Notice that is like our character: its of type Human but is instantiated as a FireArcher. Again, that’s the beauty of polymorphism. Let’s take a look at the Human class: human3 Human Character { LinkedList<Human> friendsList = LinkedList<>();... public abstract class implements private new **public** LinkedList<Human> getFriends() {  
    **return** friendsList;  
}

... } It has a LinkedList, , that accepts Human instances as elements. We will use this to hold our list of friends. Let’s get it and store a reference to it in a local variable and add the other characters to it because they are our friends: friendsList _/*store a reference to current user'sfriend list in a local variable*/_LinkedList<Human> currentUserFriendsList = currentUser.getFriendsList(); //add other user's to current user's friend listcurrentUserFriendsList.add(human2);currentUserFriendsList.add(human3);currentUserFriendsList.add(human4);currentUserFriendsList.add(human5); System. .printf( , currentUser.getFriendsList().size()); out "Current user has %d friends." //prints "Current user has 4 friends." Now we have four friends in our list. Remembered that each element in our list is stored as a Human instance, so if we want to retrieve a friend from the list, it will be returned as a Human. Let’s retrieve “Tom”, which is also an Archer: human2, Human ourFriendTomTheHuman = currentUserFriendsList.get(0); (ourFriendTom Archer) {System. .println( ); if instanceof out "\nOur friend Tom is an instance of the Archer class" Archer ourFriendTomTheArcher = (Archer) ourFriendTomTheHuman;

System.**_out_**.println(**"Tom can find more arrows for battle."**);  
ourFriendTomTheArcher.findArrows(); } {System. .println( ); else out "\nOur friend Tom is NOT an instance of the Archer class" System. .println( ); //ourFriendTom.findArrows(); doesn't work out "Tom cannot go find arrows because he is not an Archer" ourFriendTomTheHuman.attack(currentUser); } /*Prints:Our friend Tom is an instance of the Archer classTom: Found 5 arrows!Tom: I now have 8 arrows.*/ There’s a couple new things happening in that code snippet, so let’s walk through it line by line. In the first line, we call the get() instance method on our LinkedList holding our friends and get the first element which is at index zero (0). This is Tom who we know was an archer before we added him to the list. However, he was returned to us as a Human, so we call him for now. ourFriendTomTheHuman Type Casting If we want to turn Tom back into an Archer, we must him to one. Type casting in Java is the act of casting, or converting, one type, a class or interface, into another type. As usual, we should check to make sure Tom is actually an Archer disguised as a Human before we try to cast him back to an Archer. We do the check in the next line of code by using the operator in an statement. The operator returns if the object on the left is an instance of the class on the right, and it returns otherwise. In this case, it returns true because Tom is indeed an instance of the Archer class as we already knew. Now we are inside the first block of the statement. cast instanceof if-then instanceof true false if-then After printing that Tom is an instance of the Archer class, on the next line, we cast the object to an Archer and save this new copy of Tom to a new Archer variable called . As you can see, to an object, we simply put the class of type we want to cast our object to inside of a set of opening and closing parenthesis to the left of the variable holding the object. ourFriendTomTheHuman ourFriendTomTheArcher type cast You can type cast primitive values like ints and doubles, too. Do some more research on type casting because it is a handy tool. Now that we have converted Tom from being a Human back to an Archer, we can call its instance method so it can find more arrows to use in battle. If we had not converted Tom back to an Archer, he could not call the findArrows() instance method because he would not be of type Archer. However, Tom could always call the attack() instance method of Human because all Human instances have an attack method. This is where it gets a little tricky, so stick with me: findArrows() ourFriendTomTheHuman.attack(human3); /*Prints:Tom: Attacking Christina with my arrows!Christina: I've been hit. My health now = 99.0*/ Because Tom was instantiated as an Archer before being added to our LinkedList of Human objects, he still has access to the abstract Human methods that were already implemented by the Archer class and made available to Tom when he was instantiated. With that said, if we make attack , “Christina”, he still attacks with his arrows. The only problem here is, because would not be able to find arrows after he uses it all, his attack() method will be useless at that point. That is why we should cast him back to an Archer. ourFriendTomTheHuman human3 ourFriendTomTheHuman By now, I hope you understand why polymorphism is so special to object oriented programming. Moving forward, be sure to employ polymorphism in your Java programming career. Take a look at the supporting source code and change things around to practice more. Next Chapter _Congratulations on making it this far. Really, you have accomplish a great feat. The final test of how far you have…_medium.com Java for Humans {Building a GUI Fighting Game} Table of Contents _I am writing this book to teach anybody with the slightest bit of interest in computer science, software engineering…_medium.com Java for Humans {Table of Contents}

Java for Humans {Polymorphism}

Extending MapR Database Queries Using Scala Polymorphic Types

Next-Gen FHE Toolchains for the Dev Multiverse: How TFHE Is Taking Us There

You map concepts to optimized numbers TL;DR: Use real-world constants as constants Problems Bijection Violation
Debugging
Premature Optimization
Maintainability
Type Safety
Limited Extensibility Solutions Use descriptive string constants
Use Enums
Create A Polymorphic Hierarchy Context Numeric constants representing real-world concepts lack readability and make your code harder to understand. It's not clear what each number represents. if you need to add more constants in the future or change the order, you'll have to update all occurrences of these numeric constants manually. New values can introduce errors and make maintenance more difficult. Saving attributes as integers to improve the persistence performance or space is a clear signal of Premature Optimization. Sample Code Wrong public const FORMAT_JPG = 1;
public const FORMAT_GIF = 2;
public const FORMAT_PNG = 3; Right public const string FORMAT_JPG = "JPG";
public const string FORMAT_GIF = "GIF";
public const string FORMAT_PNG = "PNG";

// OR

public enum ImageFormat
{
    JPG,
    GIF,
    PNG
} Detection Semi-Automatic You can tell your linters to warn you about this usage, but they can show you some false positives. Tags Readability Level Beginner AI Generation No models create this premature optimization problem when prompted to list constants. AI Detection ChatGPT and Gemini detected this as a mistake. Conclusion After this correction, your code will be cleaner readable, and self-explanatory for debugging. You can read it and It's clear what each constant represents. If you need to add more formats or change the order, you should update the enumeration definition without affecting the rest of the code. IDEs with auto-completion and error checking will give you better support to work with enums. Relations Code Smell 02 - Constants and Magic Numbers Code Smell 110 - Switches With Defaults Code Smell 20 - Premature Optimization More Info How to Get Rid of Annoying IFs Forever Disclaimer Code Smells are my opinion. Credits Photo by Markus Krisetya on Unsplash Forget this world and all its troubles and if possible its multitudinous Charlatans - everything in short but the Enchantress of Numbers. Ada Lovelace Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code You map concepts to optimized numbers You map concepts to optimized numbers TL;DR: Use real-world constants as constants TL;DR: Use real-world constants as constants Problems Bijection Violation Debugging Premature Optimization Maintainability Type Safety Limited Extensibility Bijection Violation Debugging Premature Optimization Maintainability Type Safety Limited Extensibility Solutions Use descriptive string constants Use Enums Create A Polymorphic Hierarchy Use descriptive string constants Use Enums Create A Polymorphic Hierarchy Polymorphic Context Numeric constants representing real-world concepts lack readability and make your code harder to understand. It's not clear what each number represents. if you need to add more constants in the future or change the order, you'll have to update all occurrences of these numeric constants manually. New values can introduce errors and make maintenance more difficult. Saving attributes as integers to improve the persistence performance or space is a clear signal of Premature Optimization . integers Premature Optimization Sample Code Wrong public const FORMAT_JPG = 1;
public const FORMAT_GIF = 2;
public const FORMAT_PNG = 3; public const FORMAT_JPG = 1;
public const FORMAT_GIF = 2;
public const FORMAT_PNG = 3; Right public const string FORMAT_JPG = "JPG";
public const string FORMAT_GIF = "GIF";
public const string FORMAT_PNG = "PNG";

// OR

public enum ImageFormat
{
    JPG,
    GIF,
    PNG
} public const string FORMAT_JPG = "JPG";
public const string FORMAT_GIF = "GIF";
public const string FORMAT_PNG = "PNG";

// OR

public enum ImageFormat
{
    JPG,
    GIF,
    PNG
} Detection Semi-Automatic Semi-Automatic You can tell your linters to warn you about this usage, but they can show you some false positives. Tags Readability Readability Level Beginner Beginner AI Generation No models create this premature optimization problem when prompted to list constants. AI Detection ChatGPT and Gemini detected this as a mistake. Conclusion After this correction, your code will be cleaner readable, and self-explanatory for debugging. You can read it and It's clear what each constant represents. If you need to add more formats or change the order, you should update the enumeration definition without affecting the rest of the code. IDEs with auto-completion and error checking will give you better support to work with enums. Relations Code Smell 02 - Constants and Magic Numbers Code Smell 02 - Constants and Magic Numbers Code Smell 110 - Switches With Defaults Code Smell 110 - Switches With Defaults Code Smell 20 - Premature Optimization Code Smell 20 - Premature Optimization More Info How to Get Rid of Annoying IFs Forever How to Get Rid of Annoying IFs Forever Disclaimer Code Smells are my opinion . opinion Credits Photo by Markus Krisetya on Unsplash Markus Krisetya Unsplash Forget this world and all its troubles and if possible its multitudinous Charlatans - everything in short but the Enchantress of Numbers. Forget this world and all its troubles and if possible its multitudinous Charlatans - everything in short but the Enchantress of Numbers. Ada Lovelace Ada Lovelace Software Engineering Great Quotes Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

How to Find the Stinky Parts of Your Code: 249 - Constants as Numbers

A Digestible High-Level Overview of CPU & GPU Cores

CPU এবং GPU ক্ষমতাগুলির একটি হজমযোগ্য উচ্চ-স্তরের ওভারভিউ

Ein leicht verständlicher Überblick über die CPU- und GPU-Funktionen

Una descripción general digerible de alto nivel de las capacidades de CPU y GPU

Un aperçu digeste de haut niveau des capacités du CPU et du GPU

CPU और GPU क्षमताओं का एक सुपाच्य उच्च-स्तरीय अवलोकन

CPU と GPU の機能について、わかりやすい概要を説明します。

CPU 및 GPU 기능에 대한 소화 가능한 상위 수준 개요

Uma visão geral resumida de alto nível dos recursos de CPU e GPU

Удобный общий обзор возможностей процессора и графического процессора

CPU ve GPU Yeteneklerine Sindirilebilir Üst Düzey Genel Bakış

Tổng quan cấp cao dễ hiểu về khả năng của CPU và GPU

CPU 和 GPU 功能的易懂高级概述

Unlike most prognosticators in the cyber industry, I will try not to inflame the hype of yet another doomsday, the sky is falling discussion on the newest threat vector. Over the past quarter in particular, that has been Generative AI (GenAI). This technology has even captured the minds (and fears) of the C-Suite and Boardrooms, quite a bit differently than when security practitioners started talking about machine learning many years ago. Most (though not all) of the GenAI conversation has seemed to revolve around its ability to amplify productivity and its potential to continue the trend of automating away tasks that shouldn’t require humans. Lots of technology companies have been touting their new “AIs”, which predominantly have meant chatbots and interactive prompts. AI-powered companies have begun marketing many of GenAI’s positive expectations: predictive analytics, phishing detection & prevention, automated security patch generation, adaptive threat detection, enhanced biometrics, anomaly detection, threat simulation & training, malware generation & analysis. And Gartner recently found that one-third (34%) of organizations planned to deploy GenAI in the next 12 months. But Crowdstrike’s 2023 Global Threat report only mentions AI once, in its CEO’s opening letter about future technology. This is a strong indicator that we aren’t yet seeing it as an attack vector or amplifier in the wild. We surmise that the 2024 Global Threat report will be similar. In January, The National Cyber Security Center in the United Kingdom published a report entitled "The Near-Term Impact of AI on the Cyber Threat" detailing the potential way AI tools could be used offensively from increasing the sophistication of phishing attacks to malware and exploit development. Microsoft just corroborated that assertion with specific examples of ChatGPT-assisted phishing. This is a welcomed addition to a body of information highly focused on the new benefits of AI rather than its risks. We’ve heard and read that “soon” state-sponsored adversaries will be using GenAI to target critical infrastructure putting lives at risk. Such statements are not useful, as those adversaries have been focused on those targets forever. What matters is whether GenAI will provide useful new capabilities to compromise them. Gartner forecasts that in the next 2 years, GenAI will cause enough additional offensive capability that companies will end up spending 15% more on application and data security. Google’s recent “Cloud Cybersecurity Forecast” also indicated that Google expects GenAI to support phishing and other social engineering attacks. And CISA, which has become the US Government’s harbinger of all things cybersecurity, released a “Roadmap for Artificial Intelligence” this past November recommending developer accountability. This followed an October Executive Order by President Biden directing a variety of federal agencies to grapple with and protect against AI-enabled threats, including, for example, content authentication and watermarking by the Commerce Department and AI safety in drug discovery by the Department of Health and Human Services. So Which Risks Are Currently Accelerating? AI will increase the speed at which relatively low-quality phishing emails will be created, and likely even the sophistication of what happens after a link is clicked (chat boxes may start to replace web forms to solicit your information and bank account details). Phishing has been the overwhelmingly preferred and successful attack to establish initial access, whether through malware or password theft. The NCSC predicts that by 2025, GenAI will substantially improve the quality of Phishing emails (particularly the spelling and grammar of those emails), and thereby, increase the difficulty in identifying such malicious requests. The NCSC also predicted that the language models will be rapidly improved as exfiltrated data is reincorporated into the training models. Given its preference and preponderance, this is certainly the vector that will be impacted the soonest – automating dumb attacks. Anti-phishing training is going to have to move far beyond spotting typos to context-based evaluation. And humans are going to have to be retrained to use password managers and not re-sign into websites without careful and meticulous evaluation and contemplation. Several new anti-phishing tools seek to mitigate these risks (pixmsecurity, agari, etc.). The NCSC’s primary conclusion is that GenAI will enhance existing tactics, techniques, and procedures (TTPs) unevenly among categories of threat actors. We believe that in the near term, most of the benefit accrues to the unsophisticated as AI provides capability uplift in reconnaissance and social engineering. The NCSC states “More sophisticated uses of AI in cyber operations are highly likely to be restricted to threat actors with access to quality training data, significant expertise (in both AI and cyber), and resources. Such advanced uses are unlikely to be realized before 2025…AI lowers the barrier for novice cyber criminals, hackers-for-hire and hacktivists to carry out effective access and information gathering operations. This enhanced access will likely contribute to the global ransomware threat over the next two years.” While we appreciate the zealousness, we are skeptical of the timeframe. Over the next two years, we expect phishing emails to get more sophisticated and nation-states to continue training AIs on their incredibly large data sets. For emphasis, we’ll repeat – the near-term benefits accrue to the lowest-skilled hackers with limited resources executing TTPs in social engineering, phishing, passwords, and data exfiltration. We agree strongly that AI will also improve the efficiency of vulnerability scanning (“find me a server that is vulnerable to <fill in the blank>”). The NCSC stated that  "AI is highly likely to accelerate this challenge as reconnaissance to identify vulnerable devices becomes quicker and more precise.” To reference Alan Turing’s original formulation of Artificial Intelligence, GenAI dumb chatbots are likely to be perceived as real people relatively quickly. That will greatly enhance the ability of foreign criminals to sound like natives in their emailed requests for passwords, fund transfers, etc. Darktrace notes that GenAI has already “opened the door to providing offensive tools to more novice threat actors. But the efficacy of these tools will only be as good as those directing them. In the near term, we expect to see an increase in the speed and scale of familiar attack methodology.” The NCSC also suggests that GenAI will offer improvement in malware and exploit development and assistance in lateral movement, though we remain doubtful that in the next 5 years, there will be sufficient training models to enable vulnerability discovery available to non-nation-states or the largest 50 technology companies. The NCSC report essentially argues both sides, vacillating between two-year time frames and agreeing with this notion, by noting that GenAI tools would provide only minimal uplift for malware and exploit development for nation-states and organized cybercrime groups. But we are not saying that it’s impossible to happen relatively quickly; indeed, early last year HYAS researchers developed a proof-of-concept malware that leverages OpenAI to enable polymorphic code that can evade current cybersecurity products. And eventually (though we think it is at least 5 years out), GenAI systems themselves will be subject to data integrity attacks. What reasonable steps should we start to consider? We’ve reviewed a tremendous corpus of available literature looking for wisdom and practical advice on how to deal with these emergent threats (both the expected, near-term dumb ones and the hypothetical far away scary ones). As usual, the best tactical recommendations are the same recommendations that security teams have sought to implement since their establishment. These have become old saws by now: ● Establish governance approaches and workflow monitoring to ensure compliance with policies, standards, and procedures (whether by a human or an AI). ● Update and patch regularly against an asset registry or CMDB that consistently grows in the amount of coverage it represents (we hate that this still needs to be said). ● Monitor and block inappropriate access.  Better yet, develop a zero-trust architecture that inherently invalidates unexpected access. ● Develop continuous monitoring programs that ensure you have done all of the above (and alert you when something is out of the ordinary). ● Build strong security behavior programs to train employees toward secure, informed, and intentional behavior (no more than once a year, check the box security compliance videos). ● Monitor robust existing security control programs and quickly identify anomalous activity. ● Create relevant legal and compliance guidelines that detail appropriate use and security approvals for any GenAI activities. ● Create, disseminate, communicate, and evangelize acceptable use policies. In summary, over the next 5 years, we are most concerned about AI helping dumb attacks get faster and more automated (and minorly less dumb).  Darktrace agrees, claiming that we are “at the beginning of malicious actors’ applying AI techniques to automate more laborious aspects of their attacks.” All the current approaches to cybersecurity still hold – which is good news as most cyber teams remain highly taxed, being asked to do too much with too little. Unlike most prognosticators in the cyber industry, I will try not to inflame the hype of yet another doomsday, the sky is falling discussion on the newest threat vector. Over the past quarter in particular, that has been Generative AI (GenAI). This technology has even captured the minds (and fears) of the C-Suite and Boardrooms, quite a bit differently than when security practitioners started talking about machine learning many years ago. Most (though not all) of the GenAI conversation has seemed to revolve around its ability to amplify productivity and its potential to continue the trend of automating away tasks that shouldn’t require humans. Lots of technology companies have been touting their new “AIs”, which predominantly have meant chatbots and interactive prompts. AI-powered companies have begun marketing many of GenAI’s positive expectations: predictive analytics, phishing detection & prevention, automated security patch generation, adaptive threat detection, enhanced biometrics, anomaly detection, threat simulation & training, malware generation & analysis. And Gartner recently found that one-third (34%) of organizations planned to deploy GenAI in the next 12 months. But Crowdstrike’s 2023 Global Threat report only mentions AI once, in its CEO’s opening letter about future technology. This is a strong indicator that we aren’t yet seeing it as an attack vector or amplifier in the wild. We surmise that the 2024 Global Threat report will be similar. In January, The National Cyber Security Center in the United Kingdom published a report entitled "The Near-Term Impact of AI on the Cyber Threat" detailing the potential way AI tools could be used offensively from increasing the sophistication of phishing attacks to malware and exploit development. Microsoft just corroborated that assertion with specific examples of ChatGPT-assisted phishing. This is a welcomed addition to a body of information highly focused on the new benefits of AI rather than its risks. We’ve heard and read that “soon” state-sponsored adversaries will be using GenAI to target critical infrastructure putting lives at risk. Such statements are not useful, as those adversaries have been focused on those targets forever. What matters is whether GenAI will provide useful new capabilities to compromise them. Gartner forecasts that in the next 2 years, GenAI will cause enough additional offensive capability that companies will end up spending 15% more on application and data security. Google’s recent “Cloud Cybersecurity Forecast” also indicated that Google expects GenAI to support phishing and other social engineering attacks. And CISA, which has become the US Government’s harbinger of all things cybersecurity, released a “Roadmap for Artificial Intelligence” this past November recommending developer accountability. This followed an October Executive Order by President Biden directing a variety of federal agencies to grapple with and protect against AI-enabled threats, including, for example, content authentication and watermarking by the Commerce Department and AI safety in drug discovery by the Department of Health and Human Services. So Which Risks Are Currently Accelerating? So Which Risks Are Currently Accelerating? AI will increase the speed at which relatively low-quality phishing emails will be created, and likely even the sophistication of what happens after a link is clicked (chat boxes may start to replace web forms to solicit your information and bank account details). Phishing has been the overwhelmingly preferred and successful attack to establish initial access, whether through malware or password theft. The NCSC predicts that by 2025, GenAI will substantially improve the quality of Phishing emails (particularly the spelling and grammar of those emails), and thereby, increase the difficulty in identifying such malicious requests. The NCSC also predicted that the language models will be rapidly improved as exfiltrated data is reincorporated into the training models. Given its preference and preponderance, this is certainly the vector that will be impacted the soonest – automating dumb attacks. Anti-phishing training is going to have to move far beyond spotting typos to context-based evaluation. And humans are going to have to be retrained to use password managers and not re-sign into websites without careful and meticulous evaluation and contemplation. Several new anti-phishing tools seek to mitigate these risks (pixmsecurity, agari, etc.). The NCSC’s primary conclusion is that GenAI will enhance existing tactics, techniques, and procedures (TTPs) unevenly among categories of threat actors. We believe that in the near term, most of the benefit accrues to the unsophisticated as AI provides capability uplift in reconnaissance and social engineering. The NCSC states “More sophisticated uses of AI in cyber operations are highly likely to be restricted to threat actors with access to quality training data, significant expertise (in both AI and cyber), and resources. Such advanced uses are unlikely to be realized before 2025…AI lowers the barrier for novice cyber criminals, hackers-for-hire and hacktivists to carry out effective access and information gathering operations. This enhanced access will likely contribute to the global ransomware threat over the next two years.” While we appreciate the zealousness, we are skeptical of the timeframe. Over the next two years, we expect phishing emails to get more sophisticated and nation-states to continue training AIs on their incredibly large data sets. For emphasis, we’ll repeat – the near-term benefits accrue to the lowest-skilled hackers with limited resources executing TTPs in social engineering, phishing, passwords, and data exfiltration. We agree strongly that AI will also improve the efficiency of vulnerability scanning (“find me a server that is vulnerable to <fill in the blank>”). The NCSC stated that  "AI is highly likely to accelerate this challenge as reconnaissance to identify vulnerable devices becomes quicker and more precise.” To reference Alan Turing’s original formulation of Artificial Intelligence, GenAI dumb chatbots are likely to be perceived as real people relatively quickly. That will greatly enhance the ability of foreign criminals to sound like natives in their emailed requests for passwords, fund transfers, etc. Darktrace notes that GenAI has already “opened the door to providing offensive tools to more novice threat actors. But the efficacy of these tools will only be as good as those directing them. In the near term, we expect to see an increase in the speed and scale of familiar attack methodology.” The NCSC also suggests that GenAI will offer improvement in malware and exploit development and assistance in lateral movement, though we remain doubtful that in the next 5 years, there will be sufficient training models to enable vulnerability discovery available to non-nation-states or the largest 50 technology companies. The NCSC report essentially argues both sides, vacillating between two-year time frames and agreeing with this notion, by noting that GenAI tools would provide only minimal uplift for malware and exploit development for nation-states and organized cybercrime groups. But we are not saying that it’s impossible to happen relatively quickly; indeed, early last year HYAS researchers developed a proof-of-concept malware that leverages OpenAI to enable polymorphic code that can evade current cybersecurity products. And eventually (though we think it is at least 5 years out), GenAI systems themselves will be subject to data integrity attacks. What reasonable steps should we start to consider? What reasonable steps should we start to consider? We’ve reviewed a tremendous corpus of available literature looking for wisdom and practical advice on how to deal with these emergent threats (both the expected, near-term dumb ones and the hypothetical far away scary ones). As usual, the best tactical recommendations are the same recommendations that security teams have sought to implement since their establishment. These have become old saws by now: ● Establish governance approaches and workflow monitoring to ensure compliance with policies, standards, and procedures (whether by a human or an AI). ● Update and patch regularly against an asset registry or CMDB that consistently grows in the amount of coverage it represents (we hate that this still needs to be said). ● Monitor and block inappropriate access.  Better yet, develop a zero-trust architecture that inherently invalidates unexpected access. ● Develop continuous monitoring programs that ensure you have done all of the above (and alert you when something is out of the ordinary). ● Build strong security behavior programs to train employees toward secure, informed, and intentional behavior (no more than once a year, check the box security compliance videos). ● Monitor robust existing security control programs and quickly identify anomalous activity. ● Create relevant legal and compliance guidelines that detail appropriate use and security approvals for any GenAI activities. ● Create, disseminate, communicate, and evangelize acceptable use policies. In summary, over the next 5 years, we are most concerned about AI helping dumb attacks get faster and more automated (and minorly less dumb).  Darktrace agrees, claiming that we are “at the beginning of malicious actors’ applying AI techniques to automate more laborious aspects of their attacks.” All the current approaches to cybersecurity still hold – which is good news as most cyber teams remain highly taxed, being asked to do too much with too little.

GenAI - Soon to Be Great for Automating Dumb Attacks

A great door for hackers TL;DR: Don't use metaprogramming. It is not that cool Problems Security Limited Control Solutions Use direct calls Wrap the execution in a primitive and controlled command Sanitize it Context Developers employ the eval() and exec() functions to evaluate arbitrary expressions from strings. They can be a powerful tool in certain contexts but come with several risks and problems, especially when used with untrusted input or where the code's behavior is not fully controlled or understood. Sample Code Wrong def calculate(mathOperand, firstArgument, secondArgument):
    return eval(f'{firstArgument} {mathOperand} {secondArgument}')

# Sample usage to multiply two numbers
result = calculate('*', 4, 6)

# Injection to remove all files
calculate('', "__import__('os').system('rm -rf *')",'')) Right def calculate(mathOperand, firstArgument, secondArgument):
    if mathOperand == '+':
        return firstArgument + secondArgument
    elif mathOperand == '-':
        return firstArgument - secondArgument
    elif mathOperand == '*':
        return firstArgument * secondArgument
    elif mathOperand == '/':
        if secondArgument != 0:
            return firstArgument / secondArgument
        else:
            return "Error: Division by zero"
    else:
        return "Error: Invalid operation - Do not hack!"
        
# This is a quick solution but another smell
# You should avoid this kind of switches and iterate to 
# a Polymorphic Hierarchy Detection Automatic You can search for eval() in the code Tags Metaprogramming Level Intermediate AI Assistants Most AI Assistants avoid using eval() in their solutions. They also recognize it as a code smell and offer different options Conclusion Avoid this metaprogramming solution by hardcoding all the possible scenarios and avoiding over-generalizations. Relations Code Smell 207 - Dynamic Methods Code Smell 189 - Not Sanitized Input Code Smell 215 - Deserializing Object Vulnerability More Info https://hackernoon.com/laziness-chapter-i-meta-programming-6s4l300e?embedable=true Disclaimer Code Smells are my . opinion Credits Photo by on Yang Unsplash When you actually sit down to write some code, you learn things that you didn’t get from thinking about them in modeling terms…there is a feedback process there that you can only really get at from executing some things and seeing what works. Martin Fowler https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true

Code Smell 245 — Exec() and Eval()

SOLID design principles are the most important design principles you need to know to write clean code. Having a solid command over SOLID principles is an indispensable skill for any programmer. They are the foundation on which other design patterns are developed. In this article, we will tackle the SOLID design principles using some real-life examples and understand their importance. Together with Polymorphism, Abstraction, and Inheritance, SOLID Principles are really important to be good at objective-oriented programming. Why Are SOLID Principles Important? SOLID principles are important for multiple reasons: SOLID principles allow us to write clean & maintainable code: When we start a new project, initially the code quality is good because we have a limited set of features that we implement. However, as we incorporate more features the code starts becoming cluttered. SOLID Principles build upon the foundations of Abstraction, Polymorphism, and Inheritance and lead to design patterns for common use cases. Understanding these design patterns helps to implement common use cases in programming. SOLID Principles help us write clean code which improves the testability of the code. This is because the code is modular and loosely coupled. Each module can be developed independently and tested independently. Let’s now explore each of the SOLID principles in detail with real-world examples. 1. Single Responsibility Principle S in SOLID principles stands for Single Responsibility Principle. The Single Responsibility Principle states that a class should have only a single reason to change. This limits the number of places we need to make changes when incorporating additional requirements in our project. Each class should have exactly one reason to change. For example, let’s say we are designing a banking application in Java where we have a class that allows basic operations like debit, credit, and . The method takes an enum called (like Email, SMS, etc.) and sends the update with the appropriate medium. We will write the code for that as shown below. SavingsAccount sendUpdates sendUpdate NotificationMedium public class SavingsAccount {
    public int balance;
    public String name;

    public SavingsAccount(int initialBalance, String name) {
        this.balance = initialBalance;
        this.name = name;
        System.out.println("Created a savings account with balance = " + initialBalance);
    }

    public void debit(int amountToDebit) {
        // debit business logic
    }

    public void credit(int amountToCredit) {
        // credit business logic
    }  

    public void sendNotification(NotificationMedium medium) {
        if (medium == NotificationMedium.SMS) {
            // Send SMS here
        }
        else if (medium == NotificationMedium.EMAIL) {
           // Send Email here
        }
    }
} public enum NotificationMedium {
    SMS,
    EMAIL
} Now, if you look at the class above, it can change due to multiple reasons: SavingsAccount If there is any change in the core logic of class (like , , etc.). SavingsAccount debit credit If the bank decides to introduce a new Notification medium (let’s say WhatsApp). This is a violation of the Single Responsibility Principle in SOLID Principles. To fix, it we will make a separate class that sends the notification. Let’s refactor the code above according to the SOLID Principles public class SavingsAccount {
    public int balance;
    public String name;

    public SavingsAccount(int initialBalance, String name) {
        this.balance = initialBalance;
        this.name = name;
        System.out.println("Created a savings account with balance = " + initialBalance);
    }

    public void debit(int amountToDebit) {
        // debit business logic
    }

    public void credit(int amountToCredit) {
        // credit business logic
    }

    public void printBalance() {
        System.out.println("Name: " + name+ " Account Balance: " + balance);
    }

    public void sendNotification(Medium medium) { 
        Sender.sendNotification(medium, this);
    }
} public enum NotificationMedium {
    SMS,
    EMAIL
} public class Sender {
    public static void sendNotification(NotificationMedium medium, SavingsAccount account) {
        // extract account data from the account object
        if (medium == NotificationMedium.SMS) {
            //logic to send SMS here
        }
        else if (medium == NotificationMedium.EMAIL) {
            // logic to send Email here
        }
    }
} Now, since we have refactored the code, if there is any change in the or the format, we will change the class. However, if there is a change in the core logic of , there will be changes in the class. NotificationMedium Sender SavingsAccount SavingsAccount This fixes the violation that we observed in the first example. 2. Open/Close Principle The Open Close principle states that we should design the classes in such a way so that they are open for extension (in case of adding additional features) but closed for modification. Being closed for modification helps us in two ways: Many times, the original class source may not be even available. It could be a dependency consumed by your project. Keeping the original class unchanged reduces the chances of bugs. Since there might be other classes that are dependent on the class that we want to modify. To see an example of the Open Close Principle, let’s take a look at the example of a shopping cart (such as the one implemented on e-commerce websites). I am going to create a class called as which will contain a list of (s) that you can add to it. Depending on the type of item, and the taxation on it we want to create a method that calculates the total cart value inside the class. Cart Item Cart Classes should be open for extension and closed for modification import java.util.ArrayList;
import java.util.List;

public class Cart {
    private List<Item> items;
 

    public Cart() {
        this.items = new ArrayList<>();
    }

    public void addToCart(Item item) {
        items.add(item);
    }

    public double calculateCartValue() {
        double value = 0.0;
        for(Item item: items) {
            if (item.getItemType() == GIFT) {
                // 8% tax on gift + 2% gift wrap cost
                value += (item.getValue()*1.08) + item.getValue()*0.02
            }
            else if (item.getItemType() == ItemType.ELECTRONIC_ITEM) {
                value += (item.getValue()*1.11);
            }
            else {
                value += item.getValue()*1.10;  
            }
        }
        return value;
    }
} @Getter
@Setter
public abstract class Item {
    protected double price;
    private ItemType itemType;    
    
    public double getValue() {
        return price;
    }
} public enum ItemType {
    ELECTRONIC,
    GIFT
} In the above example, method calculates the cart value by iterating over all the items inside the cart and invoking logic based on the type of item. calculateCartValue Although this code looks correct, it violates the SOLID Principles. Let’s say we need to add a new rule for a different type of item (say Grocery) while calculating cart value. In that case, we would have to modify the original class and write another condition inside it which checks for items of type . Cart else if Grocery However, with little refactoring, we can make the code adhere to the open/close principle. Let’s see how. First, we will make the class abstract and make concrete classes for different types of (s) as shown below. Item Item public abstract class Item {
    protected double price;
    
    
    public double getValue() {
        return price;
    }
} public class ElectronicItem extends Item {

    public ElectronicItem(double price) {
        super.price = price;
    }
    @Override
    public double getValue() {
        return super.getValue()*1.11;
    }
} public class GiftItem extends Item {
    public GiftItem(double price) {
        super.price = price;
    }

    @Override
    public double getValue() {
        return super.getValue()*1.08 + super.getValue()*0.02;
    }
} public class GroceryItem extends Item {

    public GroceryItem(double price) {
        super.price = price;
    }

    @Override
    public double getValue() {
        return super.getValue()*1.03;
    }
} Inside each concrete Item classes like , ,  and implement the method which contains the business logic for the taxation and value calculation. GroceryItem GiftItem ElectronicItem getValue() Now, we will make the class depend on the abstract class and invoke the method for each item as shown below. Cart Item getValue() import java.util.ArrayList;
import java.util.List;

public class Cart {
    private List<Item> items;

    public Cart(Payment paymentOption) {
        this.items = new ArrayList<>();
    }

    public void addToCart(Item item) {
        items.add(item);
    }

    public double calculateCartValue() {
        double value = 0.0;
        for(Item item: items) {
            value += item.getValue();
        }
        return value;
    }
} Now, in this refactored code, even if new types of (s) are introduced, the class remains unchanged. Due to polymorphism, whatever is the actual type of the inside the , that class’s method would be invoked. Item Cart Item items ArrayList getValue() 3. Liskov’s Substitution Principle Liskov’s substitution principle states that in a given code, even if we replace the object of a superclass with an object of the child class, the code shouldn’t break. In other words, when a subclass inherits a superclass and overrides its methods, it should maintain consistency with the behavior of the method in the super class. For example, if we make the following classes and two classes and class. Now, let’s say we create a method called as within the Vehicle class, it can be overridden in class, but it will be unsupported in the class as doesn’t have an engine (see code sample below) Vehicle Car Bicycle startEngine() Car Bicycle Bicycle The subclass should maintain consistency with the behavior of the superclass when overriding methods. class Vehicle {
   public void startEngine() {
      // start engine of the vehicle
   }
}

class Car extends Vehicle {
  @Override
  public void startEngine() {
    // Start Engine
  }
}

class Bicycle extends Vehicle {
  @Override
  public void startEngine(){ 
    throw new UnsupportedOperationException("Bicycle doesn't have engine");
  }
} Now, let’s say there is some code that expects an object of type vehicle and relies on the method. If, while calling that piece of code instead of passing an object of type we pass a object, it would lead to issues in the code. Since the (s) class’s method will throw an exception when the method is called. This would be a violation of the SOLID Principles (Liskov’s substitution principle) startEngine() Vehicle Bicycle Bicycle startEngine() To resolve this issue, we can create two classes and and have inherit from the class and have inherit from MotorizedVehicle NonMotorizedVehicle Car MotorizedVehicle Bicycle NonMotorizedVehicle class Vehicle {
}

class MotorizedVehicle extends Vehicle {
   public void startEngine() {
      // start engine here
   }
}

class Car extends MotorizedVehicle {
  @Override
  public void startEngine() {
    // Start Engine
  }
}

class NonMotorizedVehicle extends Vehicle {
   public void startRiding() {
     // Start without engine
   }
}

class Bicycle extends NonMotorizedVehicle {
  @Override
  public void startRiding(){ 
    // Start riding without the engine.
  }
} 4. Interface Segregation Principle The “I” in SOLID Principles stands for the Interface Segregation Principle. The Interface segregation principle states that rather than having bigger interfaces that force implementing classes to implement unused methods, we should have smaller interfaces and have classes implemented. This way, classes only implement the relevant methods and remain clean. Divide your interfaces into multiple smaller interfaces rather than one big interface. For example, let’s look at the built-in Collections framework in Java. Among other data structures, Java also provides and data structure, LinkedList ArrayList class implements the following interface(s): , , , , , and . ArrayList Serializable Cloneable Iterable Collection List RandomAccess class implements , , , , , , and . LinkedList Serializable Cloneable Iterable Collection Deque List Queue That’s quite a lot of interfaces! Rather than having so many interfaces, Java developers could have combined , , , , , and into one interface, let’s say interface. Now, both and classes could have implemented this new interface. Serializable Cloneable Iterable Collecton List RandomAccess IList ArrayList LinkedList IList However, since does not support random access, it could have implemented the methods in the interface and could have thrown when somebody tries to call it. LinkedList RandomAccess UnsupportedOperationException However, that would be a violation of the Interface Segregation principle in SOLID Principles as it would “force” the LinkedList class to implement the methods inside the interface even though not required. RandomAccess Therefore, it is better to split the interface based on the common behavior and let each class implement many interfaces rather than one big interface. Dependency Inversion Principle The Dependency Inversion Principle states that classes at the upper level shouldn’t directly depend on the classes at the lower level.  This causes a tight coupling b/w the two levels. Instead of that, lower classes should provide an interface on which the upper-level classes should depend. Depend on interfaces rather than classes For example, let’s continue with the example we saw above and enhance it to add some payment options. Let’s assume we have two types of payment options with us and . Now, in the class, we want to add a method to which would calculate the cart value and initiate the payment based on the supplied payment. method. Cart DebitCard Paypal Cart placeOrder To do this, we could have added dependency in the example above by adding the two payment options as fields inside the class. However, that would tightly couple the class with and class. Cart Cart Cart DebitCard Paypal Instead of that, we would create a interface and have both the and classes implement the interfaces. Now, the class will depend on the interface, and not the individual payment types. This keeps the classes loosely coupled. Payment DebitCard Paypal Payment Cart Payment See the code below. public interface Payment {
    void doPayment(double amount);
}



public class PaypalPayment implements Payment {
    @Override
    public void doPayment(double amount) {
        // logic to initiate paypal payment
    }
}


public class DebitCardPayment implements Payment {
    @Override
    public void doPayment(double amount) {
        // logic to initiate payment via debit card
    }
}



import java.util.ArrayList;
import java.util.List;

public class Cart {
    private List<Item> items;

    private Payment paymentOption;


    public Cart(Payment paymentOption) {
        this.items = new ArrayList<>();
        this.paymentOption = paymentOption;
    }

    public void addToCart(Item item) {
        items.add(item);
    }

    public double calculateCartValue() {
        double value = 0.0;
        for(Item item: items) {
            value += item.getValue();
        }
        return value;
    }

    public void placeOrder() {
        this.paymentOption.doPayment(calculateCartValue());
    }
} If you are interested in learning more about object-oriented programming, GoF design patterns, and low-level design interviews, then do check my highly rated course Object Oriented Programming + Java Design Patterns

SOLID Principles In Java: A Beginner's Guide

জাভাতে সলিড প্রিন্সিপলস: একটি বিগিনারস গাইড

SOLID-Prinzipien in Java: Ein Leitfaden für Anfänger

Principios SOLID en Java: una guía para principiantes

Principes SOLID en Java : guide du débutant

जावा में ठोस सिद्धांत: एक शुरुआती मार्गदर्शिका

Java の SOLID 原則: 初心者ガイド

Java의 SOLID 원칙: 초보자 가이드

Princípios SOLID em Java: um guia para iniciantes

Принципы SOLID в Java: руководство для начинающих

Java'da SOLID İlkeleri: Yeni Başlayanlar İçin Kılavuz

Nguyên tắc RẮN trong Java: Hướng dẫn cho người mới bắt đầu

Java 中的 SOLID 原则：初学者指南

I know it can be hard to learn a new programming language. In this article, I want to share my plan with you. It’s a way to learn in eight weeks using videos, articles, and practice exercises. Exercises are very important because I think the best way to learn is by doing them. Python I’ve created this learning plan for people who don’t have much free time. You only need about 30–50 minutes a day and consistency. In my plan, I use the 80/20 principle, which will help you learn the most important things first and improve the rest through practice. For those who read this article to the end, I have prepared a learning tracking sheet to help you track your progress. https://youtu.be/gsnOgtnWqH4?si=mJ-Pfm7Ele-7tsK5&embedable=true Subscribe on my YouTube channel Why You Should Learn Python Python is a very popular programming language. People use it for web development, data science, artificial intelligence, scientific computing, cybersecurity, and more. Python’s syntax is simple and easy to understand, which makes it a great choice for beginners. Its simplicity helps newcomers learn the language quickly. Another important thing is career opportunities. Learning Python can lead to many job options in software development, data analysis, AI, machine learning, and more. What is the 80/20 Principle The 80/20 principle, also called the Pareto Principle, is a rule that says 80% of the results come from 20% of the efforts. If you learn the 20% of Python concepts that are most important and used the most, you can get 80% of what you need to be good at it. This means learning the basic rules, control structures, types of data, and main libraries. Instead of trying to learn everything about Python, focus on the most important parts that help you the most. How to Learn Python in 8 Weeks - The Plan Week 1: Python Basics Day 1: Introduction to Python Watch (first 10 minutes) Learn: Python Full Course for Beginners (Introduction section) Read: The Python Tutorial - Python.org Install Python and write your first script: print "Hello, World!" Exercise: Day 2: Python Variables and Data Types Watch (10 minutes) Learn: Python Variables and Data Types Read: Python Variables - W3Schools Practice creating variables of different data types: string, int, float, and bool. Exercise: Day 3: Basic Operators Watch (first 10 minutes) Learn: Python Operators Read: Python Operators - W3Schools Create simple expressions using arithmetic, comparison, and logical operators. Exercise: Day 4: Python Strings Watch (first 10 minutes) Learn: Python Strings and String Manipulation Read: Python Strings - W3Schools Practice with string concatenation, methods, and formatting. Exercise: Day 5: Control Flow - if, elif, else Watch (10 minutes) Learn: Python If Else Statements Read: Python If...Else - W3Schools Write a program that uses if, elif, and else statements to handle multiple conditions. Exercise: Day 6: Loops in Python Watch (10 minutes) Learn: Python Loops Read: Python While Loops - W3Schools Write a while loop that prints numbers from 1 to 10. Exercise: Day 7: Review and Practice Solve exercises on to review the week's concepts. Exercise: Exercism's Python Track Week 2: Data Structures Day 8: Lists Watch (10 minutes) Learn: Python Lists Read: Python Lists - W3Schools Create a list, add items, remove items, and iterate over the list. Exercise: Day 9: Dictionaries Watch (10 minutes) Learn: Python Dictionaries Read: Python Dictionaries - W3Schools Create a dictionary, add key-value pairs, access values, and use a loop to print all keys. Exercise: Day 10: Tuples Watch (10 minutes) Learn: Python Tuples Read: Python Tuples - W3Schools Create a tuple, access its elements, and understand the concept of immutability. Exercise: Day 11: Sets Watch (10 minutes) Learn: Python Sets Read: Python Sets - W3Schools Create a set, add and remove items, and perform basic set operations (union, intersection). Exercise: Day 12: Functions Watch (10 minutes) Learn: Python Functions Read: Python Functions - W3Schools Write a function that takes arguments and returns a value; call the function to test it. Exercise: Day 13: Modules Watch (10 minutes) Learn: Python Modules Read: Python Modules - W3Schools Import a module and use a function from it (e.g., module). Exercise: math Day 14-15: Review and Practice Tackle more complex exercises on . Exercise: HackerRank Python Practice Week 3: Advanced Data Structures and Comprehensions (Continued) Day 16: Dictionary Comprehensions Watch (10 minutes) Learn: Python Dictionary Comprehension Tutorial Read: Dictionary Comprehensions in Python - DataCamp Create dictionary comprehensions to transform and filter data. Exercise: Day 17: Set Comprehensions Explore set comprehensions through (Read for 10 minutes) Learn: Python Set Comprehensions Practice creating sets using set comprehensions with various conditions. Exercise: Day 18: File Handling Watch (10 minutes) Learn: Python File Handling Read: Python File Handling - W3Schools Practice opening, reading, writing, and appending to files in Python. Exercise: Day 19: Working with JSON in Python Watch (10 minutes) Learn: Python JSON Read: Python JSON - W3Schools Practice parsing JSON and converting Python objects to JSON format. Exercise: Day 20: Review and Practice Complete exercises related to this week's topics on platforms like or . Exercise: Exercism HackerRank Week 4: Functions and Error Handling Day 21: Functions Deep Dive Watch (10 minutes) Learn: Python Functions - Core Programming Read: Python Functions - Real Python Write functions with different types of parameters, default values, and keyword arguments. Exercise: Day 22: Lambda Functions Watch (10 minutes) Learn: Python Lambda Functions Read: Python Lambda - W3Schools Practice creating simple lambda functions for quick tasks. Exercise: Day 23: Error and Exception Handling Watch (10 minutes) Learn: Python Exception Handling Read: Python Try Except - W3Schools Write code blocks using try, except, else, and finally to handle errors gracefully. Exercise: Day 24: Modules and Packages Watch (10 minutes) Learn: Python Modules and Packages Read: Python Modules - Real Python Create a simple module and import it into another Python script. Exercise: Day 25-26: Intermediate Projects Start a small project to apply the concepts learned. This could be a simple data analysis using external libraries or a small web scraping script. Activity: Day 27: Review and Practice Review the week's learning and practice any concepts you find challenging. Utilize coding challenge platforms for more practice. Exercise: Week 5: Diving into Data Science with Python Learn to manipulate and visualize data using Python. Day 28-29: Get started with pandas by reading and experimenting with data frames. Learn & Practice: 10 Minutes to pandas Day 30-31: Explore data visualization with matplotlib by following the . Learn & Practice: Matplotlib Pyplot tutorial Day 32-33: Work on a data analysis project. Use a dataset from and perform data cleaning, manipulation, and visualization. Project: Kaggle Week 6: Web Development with Flask Build a basic web application using Flask. Day 34-35: Watch and set up a basic Flask project. Learn: Python Flask for Beginners Day 36-37: Expand your Flask app by adding new routes and views. Follow tutorials from the . Learn & Practice: Flask documentation Day 38-39: Create a simple web application like a to-do list or a personal diary app where users can add, delete, or edit entries. Project: Week 7: Object-Oriented Programming (OOP) Deepen your understanding of OOP in Python. Day 40-42: Dive into OOP concepts with . Practice by creating classes, objects, inheritance, and polymorphism. Learn & Practice: Real Python's OOP tutorial Day 43-44: Develop a simple command-line application (e.g., a contact book or an inventory system) using OOP principles. Project: Day 46: Go over the concepts and code from the week to consolidate your learning. Review: Week 8: Final Project and Exploration Apply all the concepts learned in a comprehensive project. Day 47-51: Start a project that interests you. It could be a more advanced data analysis project, a more complex web application, or an automation script. Plan, design, code, and test your project. Project: Day 52-53: Review your project, add documentation, and consider any additional features or improvements. Explore any libraries or frameworks that could enhance your project. Review & Extend: By the end of these eight weeks, you should have a solid foundation in Python and practical experience with a range of applications. My Personal Tips to Learn Python Effectively Use techniques like the Pomodoro Technique (study for 25 minutes, then take a 5-minute break) to maintain focus and avoid burnout. Engage with Python communities on platforms like Stack Overflow or Reddit's r/learnpython to get insights Consistency is Key. Even if it's just 30 minutes, do it daily without fail. Practice every day Learning Tracking Sheet You can download a tracking sheet from this link. It will help you track your progress and stay motivated. Download Learning Tracking Sheet That’s it! :) If you like this article, please don’t forget to share it with your friends! Thanks! Also published . here

Learn Python in 8 Weeks: The 80/20 Learning Plan with Videos, Articles, and Practice Exercises

The System Design Cheat Sheet: Relational Databases (Part 1)

Let's learn about via these 60 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Design Thinking /Learn Repo 1. A Fun Game with Post-it Notes to Learn About Your Partner A game with post-it notes that can be played both in-person or virtually using Mural or Miro for learning about your partner's likes, dislikes, and opinions. 2. How the YouTube Homepage has Changed in the Past 15 Years YouTube is an online video-sharing platform. It was created in February 2005 by Chad Hurley, Steve Chen, and Jawed Karim. In November 2006, Google bought the platform for US$1.65 Billion. The platform allows users to upload, view, share, rate, comment on videos, report, add to playlists, and subscribe to other users. 3. How to Apply Psychology Of Colors In Marketing to Your Brand This story is about how color is utilized in publicizing and marketing to summon enthusiastic responses. You can use this information to apply to your brand. 4. Become an Idea Generator via the S.C.A.M.P.E.R. Method Finding new ideas is a non-trivial exercise, and it's even more difficult to lead a team through the process of generating them: but with the scamper method you will have a real tool for generating and expanding ideas. 5. Top 10 Principles of Good Web Design Have you heard about the best trending 10 principles of good web design? Worth reading the blog. Please comment your thoughts 6. The Chicken, The Egg, and The Product Manager Here’s a scenario you might be familiar with. Say you’re starting a new role as a PM in a startup company (congrats!). You find that the startup has created a robust product with many different features and capabilities. Trying to gain some clarity and focus you ask: “which of those features are most/least used?”. Turns out, nobody knows. So you implement basic analytics mechanisms, wait for a week or two and then come back to the team equipped with a bunch of fancy graphs. 7. The Future of Product Management is No-Code Development Three months ago I decided to immerse myself in the rapidly growing world of no-code development. This is what I’ve learned. 8. An Introduction to Domain-Driven Design - Part 2 Model - a set of concepts existing in the head of the customer/project creator and terms that reflect his understanding. [9. Animation/Motion Design Tokens for Complex Design Systems](https://hackernoon.com/using-animationmotion-design-tokens-for-more-complex-and-sophisticated-design-zy3t33y5) Each Animation needs a Trigger, Duration, Easing, and Property element. Design systems also play a part in creating Motion Design and Animation. 10. Stop “Running” your Design Sprints: Prioritizing Results Over Process 5 tips on how to run result-focused design sprints from a designer at Meta & Google. Take your design sprints to another level. 11. An Introduction to Design Thinking Some of the most common approaches to solve a problem are situational or context-specific. For example, in the field of structural engineering, most of the challenges are solved by applying time tested rules in the field of civil engineering. For a problem that is considered less severe, a common approach is a trial by error. Mission-critical requirements and issues are solved by using a well-defined set of steps and strategies. The first reaction to solve any problem is to compartmentalize the problem into something which was solved earlier. The mind likes the comfort of the known after all. This is our primordial nature. These approaches have served us since time immemorial and will continue to do so. A common thread running through all these problems is they are well known, and they have been faced before plus they are well documented 12. Best Way to Make Your Design Communicate Visual hierarchy is one of the most important principles behind effective web design. I say this because the goal of a web page is to communicate, and that is essentially the same goal of good visual design. 13. Behavioral Psychology Hacks for Product Managers 14. Design Patterns: Singleton Pattern in Modern C++ In software engineering, Creational Design Patterns deal with object creation mechanisms, i.e. try to create objects in a manner suitable to the situation. The basic or ordinary form of object creation could result in design problems or added complexity to the design. In this article of the Creational Design Patterns, we’re going to take a look at the much-hated & commonly asked design pattern in a programming interview. That is Singleton Design Pattern in Modern C++ which criticizes for its extensibility & testability. I will also cover the Multiton Design Pattern which quite contrary to Singleton. 15. Thinking Like Elon Musk Means Thinking Bigger Than Big: Huge In simple language, First Principles Thinking involves actively questioning every assumption you believe. 16. A Guide to Design Thinking and Continuous Delivery from an Ex-Principal Engineer How do the big tech companies and unicorn startups succeed in agile product development while maintaining code quality. 17. Reasons Behind Creating A Website with Black Background Black has always been—if not the most popular design color—the color which designers talk about the most. It is sophisticated, energetic, mysterious, elegant, powerful, stylish, and the complete opposite of the default white. 18. The Web Design Trends you Must Not Miss in 2022 web design is moving into the future, with advanced techniques like retro revolution, fewer images, and Memphis design. 19. 'If We Don’t Systematically Re/Up-Skill, We're Condemned to Become Irrelevant': Roxana Murariu It is remarkable how Alvin Toffler predicted in the 1970s this trend of reinventing ourselves periodically through learning, unlearning, and relearning: Roxana. 20. Using Mind Mapping as a Software Engineer Mind mapping is a visual tool that can help you to organize your thoughts, ideas, and information in a way that is intuitive and easy to understand. 21. How to WOW Users With Intuitive UX Design 70% of online businesses fail because of bad usability. The solution to this challenge is an approach known as Intuitive UX Design 22. I Added Text to My ‘Pure Icon’ Site after 8 Years. Here’s Why After many years, I went from pure icons to adding descriptive text. 23. Product Management: The Johari Window Connection Ever heard about Johari Window? Psychologists Joseph and Harrington, in 1955, came up with this term when trying to help people become self-aware. While I would not want to get into too many details about it, here is just a simple explanation in case you haven’t heard about it. 24. Human Centred API Design: What Is It? As a developer, I make APIs for another system to consume so that multiple systems can talk to each other. Where is this design thingy coming from? Isn't design for UI? How is this applicable when building APIs? And what would be the benefits? I assume these would be some of the questions when looking at the title of this post. 25. What You Need to Know About Tailwind CSS 26. Inside Graphic Design: A Look at Alepo's Rebranding for the 5G Era Digital enablement and core network solutions provider Alepo has unveiled its modernized logo and updated branding. 27. A Self-Learner’s Guide to Combating UX Research & Design Misinformation UX education is saturated and it has become increasingly difficult to filter out the bad sources. Here’s how we can fix that. 28. How Experienced Software Engineers Evaluate Designs Experienced software engineers learn what works after maintaining their work for years. 29. How I ran a Successful Co-creation Workshop as a CEO How do you build something that users really want? Perhaps you could assemble a few and ask for them to make it themselves! 30. Is There Really a Hierarchy in Design? Designers should stop using the ‘Hierarchy of Design’ concept as the representation of design characteristics as a pyramid is inaccurate and misleading 31. ADPList Matches Laid-Off Designers with Mentors for Free ADPLIst is a free community that matches designers and mentors. The new platform has more than 5,000 designers and mentors. 32. The Web Metaphors In the beginning, we could only understand the Internet and the Web through the lenses of metaphors. 33. How the eBay Homepage has Changed Over the Past 21 Years eBay is a multinational e-commerce platform. It facilitates consumer to consumer and business to consumer sales through its website. eBay was founded in 1995 by Pierre Omidyar. 34. What Is The Straight-ahead Triangle And How It Can Be Used In Web Design “Straight-ahead” jazz revolutionized mid-century American culture with a relentlessly fresh and forward-thinking approach to bebop, 35. Exploring The 5 Stages of The Design Thinking Process Companies today have global exposure. Unlike earlier times, where competition among similar brands and businesses was restricted to a certain specific geographical area, competition today is on a global scale. 36. Design Thinking: The Key to Effective Marketing Campaign Do you know brands like Nike, Apple, Coca-Cola…...why these brands are so successful in their respective fields? 37. Design Thinking as a Practice for Business Innovation & Breakthrough There's no denying that Design Thinking is the way of the future. Applying this approach to a strategy and Innovation, brands can completely satisfy the needs of customers. To stay on the top, they should realize the significance of design for product success rates and have a clear understanding of a Design Thinking method. 38. Design Patterns: Prototype Pattern in Modern C++ Prototype Design Pattern is a Creational Design Pattern that helps in the prototyping(creating/copying cheaply) of an object using separate methods or polymorphic classes. You can consider the prototype as a template of an object before the actual object is constructed. In this article of the Creational Design Patterns, we’re going to take a look at why we need a Prototype Design Pattern in C++ i.e. motivation, prototype factory & leveraging prototype design pattern to implement virtual copy constructor. 39. How Good UX Designers Can Rescue Your Startup The biggest mistakes startup founders are making and real reasons why compromising on UX is detrimental to the success of your business. [40. Lean Innovation: How to Tackle Product Development in a Lean and Efficient Way](https://hackernoon.com/lean-innovation-how-to-tackle-product-development-in-a-lean-and-efficient-way-tx2b3wqu) Nowadays, it is especially important to keep the process of product development lean and efficient. Therefore it is helpful to determine the concrete goal of each phase. This makes it easier to keep the entire process goal-oriented, structured and efficient. 41. Introduction to Design Systems for UX/UI Designers For junior designers - those who have just started studying UX / UI design systems and those who have been working in this field for up to 1-2 years. The main goal of this article is to introduce you to the basic components of system design, to give you a basic introduction to this concept and to revise the material by demonstrating several examples of design systems that are already used by large companies. 42. A Great Design Is Only Half The Battle Won: Design Trends 2021 In this blog, you will learn about the Graphic design trends as we move forward in the year 2021. 43. Design Patterns: Exploring Factory Method in Modern C++ In software engineering, Creational Design Patterns deal with object creation mechanisms, i.e. try to create objects in a manner suitable to the situation. In addition to this basic or ordinary form of object creation could result in design problems or added complexity to the design. 44. 4 Must-Read Tips Before Designing Your Logo The best logos come across as simple and effortless. This is a difficult concept to wrap your head around when creating your first logo. In fact the number one issue I have had with most of my clients is their urge to overdo the design. Look at the logos of the world’s most successful brands like Nike, Twitter, or Apple. They are extremely simple and recognizable which is why I spend a good part of my time stressing this point to my clients. 45. Avatars Will Emerge as Storytellers Humans rule the world. 46. 4 Questions To Ask Yourself Before Rebranding Whether you’re a solopreneur trading on your personal reputation or
the head of a conventional business, your branding has a huge impact on
your professional success. It informs how you’re perceived: if you’re
sending a message that doesn’t resonate, or simply failing to do
anything memorable, then you’re likely to be considered mediocre or
overlooked entirely. Instead of just trying to make the best of your
underperforming brand, though, you can start moving in a positive
direction by committing to a rebrand. 47. The 10 Principles of Good Business Design how to design a winning new business / venture / product / service, rather than merely ticking off tasks on a to-do list. 48. Harnessing Growth Mindset to Design a Spider Killer I was in the middle of doing a pilates class over Zoom when I noticed a big spider on the ceiling. I pointed it out to my kids who were in the room with me, but knowing that none of us could reach it, I dismissed it and went back to struggling through “the hundreds”. Around me, the kids also resumed their activity... or so I thought. 49. The incredible story of Deft Every few years, a fresh banana peel is dropped by well-meaning experts. 50. What Holds Back Innovation? Many innovations need time to catch on because of our resistance and scepticism to a novel way to accomplish things. 51. 14 Habits Of The Growth Hacker Mindset: A Deep Dive What is a Growth hacker mindset and its 14 habits? 52. Design Patterns: Builder Pattern in Modern C++ In software engineering, Creational Design Patterns deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic or ordinary form of object creation could result in design problems or added complexity to the design. Builder Design Pattern in C++ solves this specific problem by separating the construction of a complex object from its representation. 53. Every UX Designer Needs To Learn Prototyping This article covers the definition of prototyping for UX design, when to create your first prototype, and the principles of prototyping. 54. Artistic Design  Going  From the Physical World to the Cyber Realm (Image by Patty Talavera from Pixabay) While we in the tech world we are often focused on cutting edge innovation, just as important as innovation itself is the manner in which the innovation is presented. People are drawn to an item be it a car, a computer, or a website not simply if it provides utility to the end-user, but if it is pleasant to look at. Therefore, we should look to design to gain a more complete understanding as to how innovation can be delivered in a manner that is palatable to end-users. Product designers who specialize in combining functionality with design must be multi-disciplinary, having both the ability to be methodical while also designing products that are aesthetic. 55. How to Calculate the ROI of Your Design System Design systems are a crucial success factor for digital businesses. Calculate the ROI of any design system with this ready-to-use formula. 56. Product 'Longtermism' and the Danger it May Bring There are no guarantees the future will hold the same values as us, so what right do we have to encode ours upon them? 57. How ARTH Stablecoin Was Built and Designed to Protect The User's Purchasing Power Mitul Gajera, designer of the stable value coin ARTH explains and gives insight into how the cryptocurrency was designed to protect the user's purchasing power. 58. How to Find Ideas for Web Design Learn how to look for ideas properly so you don’t waste time and energy in the future. 59. How to Create Promotional Assets: An Insider's Guide into the World of Graphic Design I offer you to go through the evolutionary stages of promo materials. 60. Secrets Of The Design Process You Wish You Knew Before The UX industry puts a lot of emphasis on processes. But is that the best way to think fundamentally about design? Thank you for checking out the 60 most read stories about Design Thinking on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

Stories, News & Mentions about POLYLOOP

Polyloop’s Stories on HackerNoon