#liskov substitution principle

[codeonedigest]

Liskov Substitution Principle Tutorial with Java Coding Example for Begi...

Hello friends, new #video on #liskovsubstitutionprinciple #solidprinciples with #Java #coding #example is published on #codeonedigest #youtube channel. Learn #lsp #principle #programming #coding with codeonedigest.

@java #java #awscloud @awscloud @AWSCloudIndia #Cloud #CloudComputing @YouTube #youtube #liskovsubstitutionprinciple #liskovsubstitutionprinciplesolid #lsp #lspprinciple #liskovsubstitutionprinciple #liskov #liskovprinciple #solidprinciples #solidprinciplesinterviewquestions #solidprinciplesjavainterviewquestions #solidprinciplesreact #solidprinciplesinandroid #solidprinciplestutorial #solidprinciplesexplained #solidprinciplesjava #singleresponsibilityprinciple #openclosedprinciple #liskovsubstitutionprinciple #interfacesegregationprinciple #dependencyinversionprinciple #objectorientedprogramming #objectorienteddesignandmodelling #objectorienteddesign #objectorienteddesignsoftwareengineering #objectorienteddesigninterviewquestions #objectorienteddesignandanalysis #objectorienteddesigninjava #objectorienteddesignmodel #objectorienteddesignapproach #objectorienteddesignparadigm #objectorienteddesignquestions

[atplblog]

Price: [price_with_discount] (as of [price_update_date] - Details) [ad_1] This book teaches you all the essential knowledge required to learn and apply time-proven SOLID principles of object-oriented design and important design patterns in ASP.NET Core 1.0 (formerly ASP.NET 5) applications. You will learn to write server-side as well as client-side code that makes use of proven practices and patterns. SOLID is an acronym popularized by Robert Martin used to describe five basic principles of good object-oriented design--Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation and Dependency Inversion.   This book covers all five principles and illustrates how they can be used in ASP.NET Core 1.0 applications. Design Patterns are time proven solutions to commonly occurring software design problems. The most well-known catalog of design patterns comes from Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, the so-called as GoF patterns (Gang of Four patterns). This book contains detailed descriptions of how toapply Creational, Structural and Behavioral GoF design patterns along with some Patterns of Enterprise Application Architecture. Popular JavaScript patterns are covered, along with working examples of all these patterns in ASP.NET Core 1.0 and C# are included. What You Will Learn: How to apply SOLID principles to ASP.NET applications How to use Gang of Four (GoF) design patterns in ASP.NET applications  Techniques for applying Patterns of Enterprise Application Architecture cataloged by Martin Fowler in ASP.NET applications How to organize code and apply design patterns in JavaScript Who This Book Is For:This book is for ASP.NET developers familiar with ASP.NET Core 1.0, C# and Visual Studio. ASIN ‏ : ‎ 1484218477 Publisher ‏ : ‎ APress; 1st ed. edition (8 April 2016) Language ‏ : ‎ English Paperback ‏ : ‎ 399 pages ISBN-10 ‏ : ‎ 9781484218471 ISBN-13 ‏ : ‎ 978-1484218471 Item Weight ‏ : ‎ 748 g Dimensions ‏ : ‎ 17.8 x 2.44 x 25.4 cm Country of Origin ‏ : ‎ India [ad_2]

[cameronmcnz]

SOLID Liskov Substitution Principle: What is it and how does it work?

[learnwithamit]

Learn SOLID Principle.

𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗶𝗻𝗴 𝗦𝗢𝗟𝗜𝗗 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀SOLID represents five principles of object-oriented programming.Whether or not you use OOP, 𝗸𝗻𝗼𝘄𝗶𝗻𝗴 𝘁𝗵𝗲𝘀𝗲 𝗽𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲𝘀 𝗴𝗶𝘃𝗲𝘀 𝘆𝗼𝘂 𝗮 𝗹𝗲𝗻𝘀 𝗶𝗻𝘁𝗼 𝘁𝗵𝗲 𝗳𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻𝘀 𝗼𝗳 𝗰𝗹𝗲𝗮𝗻 𝗰𝗼𝗱𝗲 which can be applied to many areas of programming.𝗦 — Single Responsibility Principle𝗢 — Open/Closed Principle𝗟 — Liskov Substitution Principle𝗜 — Interface Segregation Principle𝗗 — Dependency Inversion…

[nehaprem]

"Your Programming Journey Starts Here: The Best Way to Learn Java for a Beginner"

            Welcome to the world of Java programming, where we're excited to guide beginners on their journey to becoming proficient Java developers. Java is a powerful and widely used programming language known for its versatility and scalability. Our goal is to empower you with the knowledge and skills needed to create Java applications, solve real-world problems, and ultimately excel in the field of software development.

            We'll take you through a structured and effective learning path with ACTE Technologies that will help you grasp the fundamental concepts of Java, explore its powerful features, and set you on the right path to becoming a proficient Java developer. Let's begin this exciting journey into the world of Java programming, where your foray into the realm of code begins and endless possibilities await.

Certainly, here's a more detailed explanation for each of the steps:

Step 1 - Java Core:

Introduction to Java: Begin by getting familiar with the Java programming language, understanding its syntax, and how it works.

Basic Concepts: Learn fundamental concepts such as creating classes, defining methods, handling variables, and using control structures like loops and conditionals.

Object-Oriented Programming (OOP): Dive into the core principles of OOP, which are integral to Java. Understand concepts like classes, objects, inheritance, polymorphism, encapsulation, and abstraction.

Data Types: Explore the various data types available in Java, including integers, floating-point numbers, characters, and more.

Arrays and Collections: Learn how to work with arrays, which allow you to store multiple values in a single variable. Additionally, understand collections, which provide powerful data structures for managing groups of objects.

Exception Handling: Discover how to handle errors and unexpected situations in your code by implementing exception handling mechanisms.

Practice: Apply what you've learned by writing small Java programs and practicing coding exercises to reinforce your knowledge.

Step 2 - Java Core Practice:

Practical Application: Put your Java skills to the test by working on practical exercises and coding challenges. This phase is all about hands-on experience.

Problem Solving: Tackle problems like Fizz-Buzz or sorting algorithms to develop your problem-solving abilities.

Confidence Building: Gain confidence in your coding skills as you successfully complete exercises and see your code in action.

Real-World Applications: Practice writing Java code that can be used in real-world scenarios, preparing you for practical Java development tasks.

Step 3 - SQL, Networking, Threading, Performance:

SQL (Structured Query Language): Dive into the world of databases by learning SQL, which is used to manage and query relational databases. Understand concepts like creating, retrieving, updating, and deleting data.

Networking: Explore how data is transmitted between computers over networks. Learn about protocols, sockets, and network communication.

Multithreading: Understand the concept of multithreading, which allows your Java applications to perform multiple tasks concurrently. Learn how to manage threads effectively.

Performance Optimization: Discover techniques for optimizing your Java code to improve execution speed and resource utilization. Ensure your applications run efficiently.

Step 4 - Development Principles and Practices:

Software Development Principles: Learn key software development principles such as SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion). Understand how these principles contribute to writing maintainable and scalable code.

Clean Code Practices: Embrace clean code practices, which involve writing code that is easy to understand, modify, and maintain. Learn about code readability, code structure, and naming conventions.

Testing: Implement unit testing to verify the correctness of your code. Learn how to write test cases and use testing frameworks to ensure code reliability.

Collaborative Development: Engage in code reviews to collaborate with other developers and improve code quality. Learn how to provide and receive constructive feedback.

Agile Methodologies: Explore Agile methodologies such as Scrum or Kanban, which are used for effective project management and iterative development.

Version Control: Gain proficiency in version control systems like GIT to track code changes, collaborate with others, and manage code repositories.

            These steps provide a structured learning path for beginners to gradually build their Java programming skills and become proficient Java developers. Each step builds upon the knowledge and skills acquired in the previous one, leading to a well-rounded understanding of Java development.

            With the skills and knowledge you've acquired, you are well-prepared to take on real-world Java projects and contribute to the technology industry. Remember that learning is a continuous process, and your Java proficiency will continue to grow with each project and challenge you tackle. As you move forward, you'll find countless opportunities to apply your skills, innovate, and shape the future of software development.

             We're proud to have been a part of your learning journey, and we wish you every success as you continue to explore the vast world of Java programming at ACTE Technologies. If you want to learn more about Java, I highly recommend that you contact ACTE technologies because they offer certifications and job placement opportunities. Experienced teachers can help you learn better. You can find these services both online and offline. Take things step by step and consider enrolling in a course if you’re interested.

Keep coding, keep learning, and enjoy your exciting career ahead!

[azharumar]

SOLID Design Principles

SOLID stands for:

S - Single-responsiblity Principle

O - Open-closed Principle

L - Liskov Substitution Principle

I - Interface Segregation Principle

D - Dependency Inversion Principle

Single-responsiblity Principle

One class or function should be responsible of one single task only.

Open-closed Principle (OCP)

All classes should be open for extension but closed for modification. A new functionality should be implemented by using new classes and not modifying the existing classes.

Liskov Substitution Principle

Every subclass or derived class should be substitutable for their base or parent class.

PS: I kind of understood the logic, but not able to put it in words, which means I dint understand? LOL

Interface Segregation Principle

A client should never be forced to implement an interface that it doesn’t use, or clients shouldn’t be forced to depend on methods they do not use. PS: I did not understand this much. Isn't it something similar to Single-responsibility?

Dependency Inversion Principle

Dint understand a thing :D

Maybe I'll come back to this when I am more refined with programming.

[futuretechhub-in]

Learning SOLID Principles C# with Examples: Best Practices Unveiled

Learn SOLID principles c# with example and best practices. Understand Single Responsibility, Liskov Substitution, Dependency Inversion, and more. Improve code quality with real-time examples and design patterns. Master object-oriented design principles

Learning Strong Standards C# with Models: Best Practices Uncovered

Presentation

As a product designer, composing code that isn't just useful yet in addition viable and versatile is urgent. This is where Strong standards c# with model become an integral factor. Strong is an abbreviation for five fundamental plan rules that assist engineers with making powerful, adaptable, and viable code.In the impending blog entry, we will dig into reasonable code models in C# to see every one of these standards thoroughly. By the finish of this investigation, you'll have a significant handle of successfully executing these fundamental rules inside your own ventures.

What are Strong Standards?

Strong standards were presented by Robert C. Martin, otherwise called Uncle Bounce, and have turned into a foundation of item situated plan. We should momentarily go through every guideline:

Investigate the main 5 GPS tracker gadgets for productive following and area administrations.

1. Single Liability Guideline (SRP)

The Single Liability Guideline (SRP) in C# underlines that a class ought to have just a single motivation to change. All in all, a class ought to have a solitary obligation or job.

Model:

We should consider a situation where we have a Client class that handles both client data and sending messages. This abuses the SRP, as it has two unmistakable obligations.

See More info :- https://futuretechhub.in/solid-principles-csharp-with-example/

[matzdeveloper]

SOLID Principle C#

What is SOLID Principle?

'In object-oriented computer programming, SOLID is a mnemonic acronym for five design principles intended to make software designs more understandable, flexible and maintainable.'

SOLID is an acronym for the following.

S: Single Responsibility Principle (SRP)

O: Open-closed Principle (OCP)

L: Liskov substitution Principle (LSP)

I: Interface Segregation Principle (ISP)

D: Dependency Inversion Principle (DIP)

S: Single Responsibility Principle (SRP)

SRP says, "Every software module should have only one reason to change.".

Any class must have one and only one reason to change. In other words, a class must only have a single responsibility. This principle is simple, but not always easy to follow

Example

class Customer {

public function createCustomer(Request $request)

{ // Create customer

}

}

class Order {

public function submitOrder (Request $request)

{ // Submit Orders

}

}

O: Open/Closed Principle

The Open/closed Principle says, "A software module/class is open for extension and closed for modification."

Objects or entities must be open for extension but closed for modification. A class must be easily extensible without requiring modification of the class itself. The goal of this principle is to help create well-encapsulated, highly cohesive systems. 

Example

interface ISavingAccount {

public function CalculateInterest();

}

class RegularSavingAccount implements ISavingAccount {

public function CalculateInterest()

{

//Calculate interest for regular saving account

}

}

class SalarySavingAccount implements ISavingAccount {

public function CalculateInterest()

{

//Calculate interest for regular saving account

}

}

L: Liskov Substitution Principle

The Liskov Substitution Principle (LSP) states, "you should be able to use any derived class instead of a parent class and have it behave in the same manner without modification.". 

Derived types must be completely substitutable for their base types. New derived classes must just extend without replacing the functionality of old classes.

Example

class Bird{

// Methods related to birds

}

class FlyingBirds extends Bird

{

public function Fly()

{

Return “I can Fly”;

}

}

class Ostrich extends Bird

{

// Methods related to birds

}

I: Interface Segregation Principle (ISP)

The Interface Segregation Principle states "that clients should not be forced to implement interfaces they don't use. Instead of one fat interface, many small interfaces are preferred based on groups of methods, each serving one submodule.".

Clients must not be dependent upon interfaces or methods they don't use. Keeping interfaces segregated helps a developer more easily know which one to call for specific functions and helps us avoid fat or polluted interfaces that can affect the performance of a system. 

Example

interface OnlineClientInterface

{

public function acceptOnlineOrder();

public function payOnline();

}

interface WalkInCustomerInterface

{

public function walkInCustomerOrder();

public function payInPerson();

}

class OnlineClient implements OnlineClientInterface

{

public function acceptOnlineOrder()

{

//logic for placing online order

}

public function payOnline()

{

//logic for paying online

}

}

class WalkInCustomer implements WalkInCustomerInterface

{

public function walkInCustomerOrder()

{

//logic for walk in customer order

}

public function payInPerson()

{

//logic for payment in person

}

}

D: Dependency Inversion Principle

The Dependency Inversion Principle (DIP) states that high-level modules/classes should not depend on low-level modules/classes. First, both should depend upon abstractions. Secondly, abstractions should not rely upon details. Finally, details should depend upon abstractions.

This principle helps maintain a system that’s properly coupled. Avoiding high-level class dependencies on low-level classes helps keep a system flexible and extensible.

Example

interface EBook

{

function read();

}

class PDFBook implements EBook

{

function read()

{

return "reading a pdf book.";

}

}

class EBookReader {

private $book;

function __construct(EBook $book) { $this->book = $book; } function read() { return $this->book->read(); }

}

$book = new PDFBook();

$read = new EBookReader($b);

$read->read();

Conclusion:

Using SOLID principles is critical to being a really good developer and creating valuable software solutions. SOLID is essentially a balanced nutrition plan for software development. When we don’t use these principles in development, our code base becomes bloated and overweight. The system then requires extra work and attention to “trim down” or even maintain, and is at much higher risk for an emergency scare.

[nile-bits]

SOLID Principles in Action: Designing Agile and Scalable Applications

In the fast-paced world of software development, designing applications that are both agile and scalable is essential for success. The ability to quickly adapt to changing requirements and handle increased workloads is crucial for delivering software solutions that meet the demands of today’s dynamic business environments. One approach that can greatly aid in achieving this goal is the application of SOLID principles. SOLID is an acronym for five fundamental principles: Single Responsibility Principle (SRP), Open/Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), and Dependency Inversion Principle (DIP). These principles serve as guidelines for writing clean, maintainable, and robust code that can easily evolve and scale as the application grows. By understanding and applying the SOLID principles, software developers can create flexible, modular, and loosely coupled architectures that are not only easier to understand and maintain but also capable of accommodating new features and functionalities without introducing extensive modifications or risking unintended side effects. This blog post will delve into the practical implementation of SOLID principles in action, specifically focusing on their impact on designing agile and scalable applications. We will explore how each principle contributes to the overall architecture and discuss real-world examples using the C# programming language to illustrate their practical applications. By the end of this blog post, you will have a clear understanding of how SOLID principles can be effectively utilized to create software systems that exhibit the characteristics of agility, scalability, maintainability, and extensibility. So, let’s dive into the world of SOLID principles and discover how they can revolutionize the way we design software for agile and scalable applications.

Learn more here:

https://www.nilebits.com/blog/2023/06/solid-principles-in-action-designing-agile-and-scalable-applications/

[codeonedigest]

Dependency Inversion Principle Tutorial with Java Program Example for Beginners  

https://youtu.be/_v7JVQsRkN4 Hello friends, new #video on #dependencyinversion #solidprinciples with #Java #coding #example is published on #codeonedigest #youtube channel. Learn #dip #dependency #inversion #principle #programming #coding with codeonedi

 Dependency Inversion Principle is the fifth and final Solid principle. Robert C. Martin’s definition of the Dependency Inversion Principle consists of two parts. High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions. An important detail to note here is that high-level and…

[some-programming-pearls]

Why you should be using SOLID

If you’re a software developer, there’s a good chance you’ve heard of the SOLID principles. These five principles were first defined by Robert C. Martin in his 2000 book “Agile Software Development, Principles, Patterns, and Practices”. The SOLID principles are: S — Single responsibility principle O — Open/closed principle L — Liskov substitution principle I — Interface segregation…

[sagharmax]

Clean Code Rules: 21. Use SOLID principles SOLID is an acronym for five coding principles for writing better code. These principles help develop any application but have been especially useful for object-oriented programming. ○ Single responsibility principle: A class or a method should have only one reason to change. ○ Open/closed principle: A class should be open for extension but closed for modification. ○ Liskov substitution principle: Base type should be substitutable for child types without breaking the functionality. ○ Interface segregation principle: No client should be forced to depend on properties and methods it does not need. ○ Dependency inversion: High-level modules should not depend on low-level modules. They should depend on abstractions. Abstractions should be independent of details. Details should depend on abstractions. #software_development #programming #dotnet #csharp #dotnetdevelopment #webdevelopment #coding #workstation #workdesk #clean_code #uncle_bob #robert_c_martin #sagharmax (at Urmia) https://www.instagram.com/p/CpiPV2koZMn/?igshid=NGJjMDIxMWI=

[offpagefalcon]

Mastering Object-Oriented Design: Principles, Practices, and Benefits

Object-oriented design (OOD) is a cornerstone of modern software engineering, offering a systematic approach to solving complex problems. By focusing on objects rather than processes, object-oriented design allows developers to create flexible, scalable, and maintainable systems. This article explores the principles, practices, and advantages of this paradigm, empowering you to design software that stands the test of time.

What is Object-Oriented Design?

At its core, object-oriented design is a methodology that models software as a collection of interacting objects. Each object encapsulates data (attributes) and behavior (methods), mimicking real-world entities. This approach contrasts with procedural programming, where the focus is on functions and their sequence of execution.

In object-oriented design, the goal is to break down a system into manageable pieces, leveraging four fundamental principles:

Encapsulation: Bundling data and methods together to hide implementation details.

Abstraction: Simplifying complex systems by modeling only essential features.

Inheritance: Allowing new classes to derive properties and behaviors from existing ones.

Polymorphism: Enabling a single interface to represent different underlying forms.

Key Principles of Object-Oriented Design

1. Encapsulation

Encapsulation ensures that internal details of an object are hidden from the outside world. This promotes modularity and reduces interdependencies, making code easier to maintain. For example, consider a Car object:

python

Copy code

Here, the car's attributes (make and model) are private, accessed only through public methods.

2. Abstraction

Abstraction involves focusing on the essential characteristics of an object while ignoring irrelevant details. This principle simplifies complex systems and fosters clarity. For instance, a Payment class might abstract specific payment methods while providing a unified interface:

python

3. Inheritance

Inheritance enables code reuse by allowing a new class to adopt properties and methods from an existing class. For example, a Vehicle class can serve as a base for Car and Truck classes:

python

4. Polymorphism

Polymorphism allows objects of different types to be treated uniformly. This principle enhances flexibility and supports dynamic behavior. For example, a Shape class can define a draw method that is implemented differently by subclasses like Circle and Square.

Benefits of Object-Oriented Design

Reusability: By leveraging inheritance and polymorphism, developers can create reusable components, reducing redundancy and saving development time.

Scalability: Encapsulation and modularity allow systems to scale gracefully as new features are added.

Maintainability: Abstraction and clear separation of concerns make codebases easier to understand, debug, and extend.

Real-World Modeling: By mimicking real-world entities, object-oriented design bridges the gap between human thought processes and software implementation.

Flexibility: Polymorphism enables dynamic behavior, allowing systems to adapt to changing requirements.

Best Practices for Object-Oriented Design

1. Apply the SOLID Principles

The SOLID principles provide a guideline for creating robust and maintainable designs:

Single Responsibility Principle: Each class should have only one responsibility.

Open/Closed Principle: Classes should be open for extension but closed for modification.

Liskov Substitution Principle: Subtypes should be substitutable for their base types.

Interface Segregation Principle: Clients should not depend on unused interfaces.

Dependency Inversion Principle: High-level modules should not depend on low-level modules.

2. Favor Composition Over Inheritance

While inheritance is a powerful tool, overusing it can lead to tight coupling. Composition, where objects are composed of other objects, offers greater flexibility.

3. Use Design Patterns

Design patterns, such as Singleton, Factory, and Observer, provide tried-and-tested solutions to common design problems in object-oriented design.

Common Challenges and How to Overcome Them

Over-Engineering: Avoid creating overly complex designs. Focus on solving the problem at hand.

Tight Coupling: Use interfaces and dependency injection to reduce dependencies between classes.

Lack of Abstraction: Ensure your design models the real-world domain accurately without unnecessary details.

Real-World Applications of Object-Oriented Design

Object-oriented design is the backbone of many industries, including:

Web Development: Frameworks like Django (Python) and Ruby on Rails use OOD principles.

Game Development: Game engines like Unity rely heavily on object-oriented principles for modeling game entities.

Enterprise Software: Business applications leverage OOD for scalability and maintainability.

Conclusion

In today's ever-evolving technological landscape, mastering object-oriented design is essential for creating robust and adaptable software. By adhering to its principles and best practices, developers can tackle complexity, streamline workflows, and build systems that grow with user needs. Whether you're developing a simple application or architecting enterprise solutions, OOD offers the tools and mindset for success.

Embrace object-oriented design to transform your software development approach and unlock endless possibilities.

[mustafabukulmez-blog]

S.O.L.I.D Kısaca Nedir?

Merhabalar, bu yazımızda S.O.L.I.D Kısaca Nedir? ona bakacağız. İlerleyen zamanlarda her maddesine tek tek bakacağız ancak genel çerçeveyi çizmek için ilk olarak özet bilgi vereceğim. Gelin S.O.L.I.D kısaca nedir bir bakalım.   S.O.L.I.D Kısaca Nedir? SOLID bir yazılım geliştirme prensibidir. SOLID’in 5 maddesi bulunur ve adını da bu maddelerin baş harflerinden alır. Çıkış amacı, geliştirilecek…

[certainsuitkid]

Liskov Substitution Principle https://ift.tt/3lt86zI

[halfusek]

okay so now multiple people have asked me about one of the themes - dependency inversion - so i think at this point i should make a post about it

you might have noticed that in this year’s theme list i’ve included the 12 disney animation principles - I’ve modified the names a bit so they can work better as themes:

  15. Squash And Stretch   16. Anticipation   17. Staging   18. Pose (original principle: Straight ahead action and pose to pose)   19. Action (original principle: Follow through and overlapping action)   20. Slow In And Slow Out   21. Arc   22. Movement (original principle: Secondary action)   23. Timing   24. Exaggeration   25. Dimension (original principle: Solid drawing)   26. Appeal

i thought it’d be a fun idea to include them, though as with any other theme you are free to interpret them however you wish! it doesn’t need to be related to the animation principles at all, you do you :)

i have also added another list of principles like that to the theme list - programming principles, i have also altered their names so they can work better as themes:

  3. Responsibility (original principle: Single-Responsibility)   4. Open/Closed   5. Substitution (original principle: Liskov Substitution)   6. Abstraction (original principle: Interface Segregation)   7. Dependency Inversion

If you are not familiar with programming then these might look extremely weird to you and googling won’t help you much (like what the fuck is Liskov Substitution am i right) but it is not the point that you need to understand these programming terms - they were just an inspiration for me to create themes that I think can be applied to bendy related art, like for example character’s having responsibilities, closed doors, replacing (substituting) one character with another, abstract art, swapping one character being dependent on another to portray a different dynamic between them - but yeah those are just examples, as i said, you can interpret them however you like and you do not need to grasp any programming definitions for that :)

i know that some may think of programming inspiration as out of place for an art event, like animation principles make sense but programming is a bit wild, but i did it for a reason

this fandom (and fandoms in general) have members that do tackle with programming, be it dataminers, modders or fangame creators for example; and plenty of them unfortunately got lots of bad reputation in the bendy fandom - for example dataminers being looked down on because “they dont play the game normally” even though their efforts helped us all a ton in getting references for our theories and even drawings because we are able to see the game models

and don’t even get me started on how the bendy devs treat fangames, it’s truly a sad thing that it is so hard to create a bendy fangame that will be accepted by them; i think it’s really unfair to take down fangames that have entirely original assets, i mean how different are they from fanfictions or fancomics? they are telling stories, just with a different medium

not to mention that strong fangame communities help a ton with keeping fandoms active and i’m pretty sure if the bendy devs weren’t so harsh on them, they’d get a ton of free marketing but oh well their loss

but yeah, just wanted a bit of appreciation for the developing/modding folks :)