#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.

[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…

[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/

[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.

[anantradingpvtltd]

Price: [price_with_discount] (as of [price_update_date] - Details) [ad_1] Part 1: Class Design.- Chapter 1: The Single Responsibility Principle.- Chapter 2: The Open/Closed Principle.- Chapter 3: The Liskov Substitution Principle.- Chapter 4: The Interface Segregation Principle.- Chapter 5: The Dependency Inversion Principle.- Part 2: Package Design.- Chapter 6: The Release/Reuse Equivalence Principle.- Chapter 7: The Common Reuse Principle.- Chapter 8: The Common Closure Principle.- Chapter 9: The Acyclic Dependencies Principle.- Chapter 10: The Stable Dependencies Principle.- Chapter 11: The Stable Abstractions Principle.- Chapter 12: Conclusion.- Appendix A: The Full Page Class.- Publisher ‏ : ‎ APRESS; 1st edition (1 January 2018) Language ‏ : ‎ English Paperback ‏ : ‎ 296 pages ISBN-10 ‏ : ‎ 1484247469 ISBN-13 ‏ : ‎ 978-1484247464 Item Weight ‏ : ‎ 480 g Dimensions ‏ : ‎ 20 x 14 x 4 cm Country of Origin ‏ : ‎ India [ad_2]

[eves-swe]

CS373 Fall 2022: Evelyn Vo: Final Entry

How well do you think the course conveyed those takeaways? I think the takeaways were conveyed well when they were being taught but I honestly don't think I retained them that well.

Were there any other particular takeaways for you? Most of my takeaways are technical skills I learned while working on the IDB project, especially with React. I had no experience in React beforehand and most of my work for IDB was on the back end but I had groupmates that were already experienced in React and wrote good code that I could just pick up where they left off and contribute well.

How did you feel about cold calling? Cold calling did and still makes me nervous. I don't really like answering questions about myself. I felt that the question about people's internship experience over the summer could be alienating to those who were not able to intern or who worked for lesser known companies and that it could create an elitist environment. Maybe avoid asking this kind of question in the future.

How did you feel about specifications grading? It didn't change my approach to the assignments in this class compared to any other CS course. I always just tried to get every requirement down possible. Sometimes my group would get a 2/3 unexpectedly on an assignment where we knew we were missing some key components so maybe spec grading is more forgiving than we thought but I never tried to calculate my actual grade.

How did you feel about help sessions and office hours? I didn't go to any help sessions or office hours.

How did you feel about the support from the TAs? I liked working with Canyon who was in charge of checking in with our group. Canyon offered us help whenever we were stuck with something and provided us with some great resources during the project development.

You should have read five papers that describe SOLID design: Single Responsibility, Open-Closed Principle, Liskov Substitution, Interface Segregation, and Dependency Inversion. What insights have they given you? I vaguely learned most of these principles on the job during my internship this past summer, so these papers gave me better insight into the reasoning behind the design principles.

You should have read two papers that advised minimizing getters and setters. What insights have they given you? Sometimes I would write getters and setters just because I had always done them for every other class definition I was writing. These papers taught me that if it isn't necessary, don't do it.

What required tool did you not know and now find very useful? AWS. Although it was very difficult to set up, I think it was an important tool to learn and I'm glad I got to experience creating a fully functioning website with it.

What's the most helpful Web dev tool your group used that was not required? The mui/material library. This library has many pre-made UI components for input data that were easily customizable. I think this library provides a lot of React components that will save time during front end development in future projects.

How did you feel about your group having to self-teach many technologies? I didn't really like it. Although the experience was useful and would provide me with material for future interviews, it made signing up and coming to this class very pointless. The lectures about python and relational algebra were the most useful to me but they felt irrelevant to the IDB project. I think if I had the motivation and idea, I could have done this project and self teach myself all the tools I needed to and take a different CS course instead (or do it all in an internship and get paid to do it). I think if the teaching staff had a hand in teaching or at least introducing us to the tools necessary for the projects, it would have felt more worthwhile coming to class. If you teach/introduce any tool in this class, I think it should definitely be how to set up the AWS instance considering how so many teams struggled to stay within Amazon's free tiers. The added stress of being billed $200+ and trying to get that money back along with working on the project and no accountability by the teaching team seems like it could all be avoided with a little guidance on how to set the free tier limits. I remember trying to set up our team's API endpoint and had no idea where to start. I didn't know what I had to google to even start and don't think I would have ever figured out that I had to set up an Elastic Beanstalk instance along with an API Gateway without my roommate who had already learned these things from working at Amazon.

In the end, how much did you learn relative to other UT CS classes? I learned more technical skills in development technologies than in other classes which I liked, but it felt like I was thrown into the deep end of the pool. I would have preferred a more guided learning experience.

In addition to the questions above, I wanted to mention that my roommate had a female friend take this class and felt discriminated by her group mates. She had gone to the teaching staff about this problem and received no support. We recently read a paper about sexism in the software industry and had a guest speaker bring awareness to this issue for our class. I find it hypocritical that we're told how important it is to support women in this industry yet women don't seem to get that support from the teaching staff. Being so mistreated before our early career even starts contributes to less and less women staying or moving up in the tech industry and if the teaching staff cares about this issue, they should provide better ways to empower their female students.

[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…