DEV Community: Aatmaj

Cool Github repositories for Everyone

Aatmaj — Thu, 29 Dec 2022 10:43:24 +0000

📒 Useful repositories for every developer!!

This is a hand picked and carefully curated collection of cool github repositories. These repositories offer many courses/tutorials/materials for learning a variety of stuff!

So what are we waiting for! Let's get started!

Dont forget to star the Original github repo 🤩

Follow me on Github!

Data structures
Machine learning
Math
Flutter and App dev
IOT
University
Interview prep
CP
IOS
Blockchain
Cloud computing
Web dev
Security
Language resources questions and cheatsheets
Data base
cheatsheets
Awesome github repositories
git
Others

Data structures

Machine learning

Math

Flutter and App dev

IOT

University

Interview prep

CP

IOS

Blockchain

Cloud computing

Web dev

Security

Languageresources questions and cheatsheets

Data base

cheatsheets

Awesome github repositories

git

Others

🤝 Help grow the community

Know a cool repo? Let us know by opening a pull request!

5 proverbs for rapid development

Aatmaj — Fri, 22 Oct 2021 06:06:40 +0000

Let us see five proverbs which fit perfectly to the rapid development scenario.

An ounce of protection is worth a pound of cure.

A little precaution before a crisis hits is better than lot of firefighting afterwards.
Many times, developers neglect risk management. Risk management, identification and prevention are more critical than we think. Unidentified risks cause a lot of trouble in the later stages of software development. This is why, preventing such risks is wiser than to fix them after they get worsened. Identifying risks and taking precautions against them, that is protecting the project against the risk is a key to rapid development.

A stich in time saves nine

Correction at early stages saves work later.
In a software development lifecycle, doing right things at the right time is very important. If work is delayed in the earlier stages, it can causes much trouble afterward. Example a flaw in the design time is not fixed is bound to cause a disaster. And one flaw in the implementation time if not fixed will take almost triple the time to fix at the debugging phase.

Cross the stream where it is shallowest.

Don't complicate things unnecessarily.
Many developers believe that the more complicated things will be made, the better the project will execute. But that's not the case. In reality complicated practices, stringent methodologies actually lengthen the process rather than making it faster. This is why many times the simple is the best. Complex design patters, complex code leads only to increasing the clutter of the program. Yes, this doesnt mean that one must nor use complex patterns or code. This means that one must always strive for a simpler solution to the problem.

Watch the doughnut, and not the hole.

Focus on what you have rather than at what you don't.
In a software development lifecycle, one cannot get all the aspects perfect. In that case, you need to maximize what you have over what you don't. For example you might not have trained personnel, or say might not have enough time. But in such cases, you must focus on what you have and try to give the best possible. Focus on your strengths and try to win the match.

Too many cooks spoil the broth.

If too many people are involved in a task or activity, it will not be done well.
This is often the case with software development scenarios. Too many people who are experienced and have their own different viewpoints. While difference in perspectives always leads to better ideas, there must be only one decision maker whome everyone must follow. Disagree but commit must be the case with those who are the subordinates. If too many people are decision makers, then it will lead to chaos.

Waterfall with subprojects

Aatmaj — Thu, 21 Oct 2021 11:38:13 +0000

One most significant problems with the pure waterfall model from a rapid development point of view are that you're supposed to be completely done with an architectural design before you begin with a detailed design, and you're supposed to be completely done with the detailed design before you begin coding and debugging. However, in the practical world, systems do have areas that contain design surprises, but they have other areas that we have implemented many times before and contain no surprises. Delaying the implementation of the areas that are easy to design just because the design of a difficult area is pending is not a good idea. If the architecture has broken the system into a logically independent system, you can spin off separate projects, each of which can proceed at its own pace.

This is what is called as the waterfall with sub-projects model. In this model, the waterfall is broken into different parts and the subprojects are executed independently into waterfall streams.

The main risk

This model a very vulnerable risk, that is unforeseen interdependencies. You can partly account for that by removing dependencies at the architecture time or waiting until
detailed design time to break the project into subprojects.
Careful planning can allow you to perform some of the waterfall's task in parallel.

Notes and images from Rapid Development: Taming Wild Software Schedules by Steve McConnell

Sashimi Waterfall model of development

Aatmaj — Thu, 21 Oct 2021 11:36:57 +0000

Sashimi Waterfall model of development

The name Sashimi comes from the Japanese style of presenting raw fish, where the slices overlap each other. In the sashimi model, too the stages overlap each other to overcome the drawbacks of the traditional waterfall development model.
The sashimi model of development is a modification to the traditional waterfall model.
The traditional waterfall provides minimal overlapping between the two stages of development. But that s not the case with the Sashimi model of development.
This model suggests a stronger degree of overlap between the stages-For example, suggesting you might be well into architectural design partway between the structural analysis and perhaps partway into the detailed designing before you consider requirements analysis to ve complete. This is a reasonable approach for many projects, which tend t gain important insights into what they are doing as they move through their development cycles and which function poorly with their strictly sequential development plans. In the pure waterfall model, the ideal documentation is that one team can to a completely separate team between any two phases. The question is, "why?" If you can provide personnel continuity between all stages of software development, you don't need much documentation. This wa, by following modified waterfall model, you can substantially reduce the need for documentation.

The disadvantages.

The Sashimi model is no without problems. Because there is an overlap between the phases, milestones are more ambiguous, and it's harder to track progress accurately. Performing activities in parallel can lead to miscommunication, mistaken assumptions and result in inefficiency. If you are working on a small, well-defined project, something close to the pure waterfall can be more efficient instead.

Notes and images from Rapid Development: Taming Wild Software Schedules by Steve McConnell

If you liked the post, please like it and follow me on Github!

Follow me on Github!

Learning Python Intermediate Course- yearning for suggestions

Aatmaj — Tue, 19 Oct 2021 15:46:10 +0000

The intermediate part of the Learning Python course ended last week.
In case you missed it, you might check out the series here. So I am asking you all for any suggestions you might want to add to help me improve.

So guys if anyone of you have any suggestions of doubts or anything to add, please comment them below. 😊

Spiral lifecycle model Part 2

Aatmaj — Mon, 18 Oct 2021 07:54:22 +0000

In the last post, we studied about the spiral lifecycle model. Let us now continue discussing about the model in this part. Just in case you missed it, you can check it out here

Advantages of the model

The spiral lifecycle model helps you analyze risks and eliminate them before they get too big. One of the moist important advantages of the spiral model is that as the cost increases, the risk decreases. The more time and money you spend, the lesser risk you are actually taking, which is exactly what we all want in any lifecycle model.

The spiral model provides at least as much management control as the traditional waterfall model, you have the checkpoints ready just from the start of every iteration. Because the model is risk oriented, it provides you with the early indications of any risks possible. If in the worst case, the project cant be done for technical or any other reasons, you will find that out early on. Moreover the users can see the system easily from the start due to effective prototyping. This results in Early user engagement

The spiral lifecycle model can be coupled with other lifecycle models in a couple of different ways. This is why this model is very adaptable. And yes, the transition from building a project to maintaining it is so smooth that this boosts the overall maintainability of the project

Disadvantages

The only disadvantage of the spiral model is that it's a lot complicated. It requires conscientious, attentive and knowledgeable management. It can be difficult to define objective, verifiable milestones that indicate weather you're ready to add the next layer to the model or not. In some cases, the product development is straight forward enough and project risks are modest enough that you don't need the flexibility and risk management provided by the spiral model. Not suitable for small or low risk projects and could be expensive for small projects.

When to use this model

Use this model when you have an experienced management staff. Use in projects where user involvement is to be preferred over expected time to complete.

Use For

For medium to high-risk projects.

When there is adequate to fair time.

Learning Python- Intermediate course: Day 44, Summary of the week, examples and exercises

Aatmaj — Sat, 16 Oct 2021 06:05:44 +0000

Today we will have a quick summary of the week

Let us see a sample OOP program

class animal:
 food=""
 def makenoise(Self):
     pass

class pet():
    def bepetted(self):
        print("Pet me")

class canine():
    def shownails(self):
        print("My nails are long")

class dog(pet):
    def __init__(self):
        print("I am a dog")
        self.food="bone"
    def makenoise(self):
        print("Woof!")

class cat(pet,canine):
    def __init__(self):
        self.food="milk"
        print("I am a cat")
    def makenoise(self):
        print("meow!")

Tommy=dog()
Tommy.makenoise()
Tommy.bepetted()
print(Tommy.food)
Dina=cat()
Dina.shownails()
Dina.bepetted()
print(Dina.food)

I am a dog
Woof!
Pet me
bone
I am a cat
My nails are long
Pet me
milk

Exercises-

1) Correct the following code

class sample():
 def fun(self):
  print("yo!")

mysample=sample()
sample.fun()

Traceback (most recent call last):
  File "main.py", line 6, in <module>
    sample.fun()
TypeError: fun() missing 1 required positional argument: 'self'

2) Correct the following code

class sample():
 def fun():
  print("yo!")

mysample=sample()
mysample.fun()

Traceback (most recent call last):
  File "main.py", line 6, in <module>
    mysample.fun()
TypeError: fun() takes 0 positional arguments but 1 was given

3) Extend the above program to include a class tiger and class wild. Add attribute habitat to wild and pet. Use iterable for in loop to call out the methods (hint use try except)

Day 41

We learnt about inheritance in Python
Inheritance is an OOP concept which provides flexibility and code reusability to the program. We can make changes to the program without altering much code. We can also extend the code by adding new functionality without much effort. Inheritance in Python is achieved by adding the name of the super classes inside the constructor of the new class. In this part we studied how functions and properties are inherited from the super class. But object constructors are not inherited by the subclasses, however the number of arguments for constructors must be the same for both if the classes. Functions are overloaded in the subclasses, that is the functions with same name can be present in both the subclass and the super class. In such cases, the functions of the sub-class are considered as effective. Constructors and methods of the superclass can be called by the super() method in case of overloading.

Day 42

In this part we learnt about polymorphism, yet another OOP feature. Just like inheritance, polymorphism too does help in making the program more extendable and flexible. Using polymorphism, we can create new subclasses without doing much change into the superclass. Polymorphism is a technique by which subclasses can be considered as types of super-classes. Polymorphism in Python is achieved through overwriting of methods.

Day 43

In this part we covered some more of OOP. We covered concepts which are not directly supported by Python, like abstraction and interfaces. We saw a brief about duck typing and how to resolve the Deadly Diamond of Death. This part was just intended to bring together a feeling of completeness regarding OOP concepts and not a complete guide towards OOP.

Intermediate part of the course ends today.

So friends, this marks the end of the Learning Python intermediate course. I will be soon providing you all with the summary of the intermediate course.

Learning Python- Intermediate course: Day 43, DDD and more on OOP

Aatmaj — Thu, 14 Oct 2021 11:12:16 +0000

Today we will cover some OOP properties that are not covered in Python and look at how Python resolves the Deadly Diamond of Death.

Python is a language mainly designed to use for data oriented analysis. Today, the most popular use of Python is Data science and ML. Although Python is used as a full-stack to some extent, heavy backending applications which require OOP are still made in Java to a certain extent.

Java is OOP. It is the best suited for design patterns and other beautiful OOP stuff. Python is suited for Data science.. This is why probably Python doesn't support a few features of OOP which are critical to design patterns. Two most significant features are Abstract classes and interfaces

Although these features may not be available in core Python, we can still use them with the aid of a module know as abc But that is not for this course.

Disclaimer! Advanced concepts like Multiple inheritance, duck typing, abc module will be covered in the advanced part of this course. This part is only for a brief upon those concepts.

Interfaces

Why do we even need interfaces when Python supports multiple inheritance? An interface is the Java workaround for multiple inheritance. All features of interfaces are covered by two python aspects- multiple inheritance and duck typing.

Still, a few use cases of interfaces are not resolved fully. If you want to make base classes that cannot be instantiated, but provide a specific interface or part of an implementation, interfaces are a must.

Duck typing in Python

"If it walks like duck, swims like duck, looks like a duck, then it probably should be a duck."

In other words, of a class has methods, properties of another class, it is another class. This simply means types go for a toss in Python as long as methods and attributes are the same.

I know you have not understood anything.... this will be covered in detail in the advanced part of this course.

Multiple inheritance in Python

Python supports multiple inheritance. This means that one class can inherit two or more classes. The method resolution is done clearly in Python, unlike C++ and helps resolve most of the issues
More about it in the advanced part of this course

Deadly Diamond of Death

Python has a simple way of handling the diamond problem. The method of the first superclass passed is called.

Let us continue with yesterday's program

class ape():
    food=""
    def __init__(self,weight):
        self.weight=weight
    def cry(self):
        pass # Do nothing
    def eat(self):
        print(self.food)

class chimpanzee(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="bananas"
    def cry(self):
        print("I am a chimp")

class gorrilla(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="fruits"
    def cry(self):
        print("I am a gorrilla")

class gorranzee(chimpanzee,gorrilla):
    pass

A=gorranzee(20)
print(A.food)
A.cry()

bananas
I am a chimp

class ape():
    food=""
    def __init__(self,weight):
        self.weight=weight
    def cry(self):
        pass # Do nothing
    def eat(self):
        print(self.food)

class chimpanzee(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="bananas"
    def cry(self):
        print("I am a chimp")

class gorrilla(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="fruits"
    def cry(self):
        print("I am a gorrilla")

class gorranzee(gorrilla,chimpanzee):
    pass

A=gorranzee(20)
print(A.food)
A.cry()

fruits
I am a gorrilla

If gorilla is passed first, then the cry() method and constructor of gorilla class will run. And if chimpanzee is passed first, then the cry and constructor of chimpanzee class will be run.

Abstract classes

In the above example, ape was the class which needn't be instantiated, and could have been made an abstract class. But Python doesn't support abstract classes in an built way. However, modules can be used to implement abstractions.

abc module

The abc (Abstract Base Classes) is a inbuilt Python module which enables the usage of abstract classes and inheritance in Python.
This module provides the metaclass ABCMeta for defining ABCs and a helper class ABC to alternatively define ABCs through inheritance.

The package zope.interface provides an implementation of “object interfaces” for Python. It is maintained by the Zope Toolkit project. The package exports two objects, ‘Interface’ and ‘Attribute’ directly. It also exports several helper methods. It aims to provide stricter semantics and better error messages than Python’s built-in abc module.

The Twisted Plugin System is an alternative to the zope interface.

And at last, before ending today's last session, some philosophical sermon

Python follows the EAFP (Easier to Ask Forgiveness than Permission) rather than the LBLY (Look Before You Leap) philosophy. The EAFP is somewhat linked to the "duck typing" style.

Learning Python- Intermediate course: Day 42, Polymorphism.

Aatmaj — Wed, 13 Oct 2021 14:32:32 +0000

Today we will learn about Polymorphism in Python

What exactly is Polymorphism

Polymorphism is an OOP feature which provides extensibility and flexibility to your code. The major advantage of Polymorphism is flexibility. Polymorphism gives you the the flexibility lost in inheritance.

Poly - many
morphism -many forms
Polymorphism is the condition of occurrence in different forms.

Polymorphism in operators

We use polymorphism when dealing with operators. For example the + operator is used to add two numbers as well as to coconcate two strings. In the same way, the product operator * is used to multiply two integers, floating numbers as well as two complex numbers in Python. This is an example of polymorphism which we have unknowingly used until now.

Polymorphism in functions

Till now we have come across many functions which take in arguments of various multiple types. For example the print function takes in lists, tuples, numbers, complex numbers as well as strings. Another example is the len() function which takes in any iterable type. when string is passed, it returns the number of characters, when list is passed it returns the number of elements and when a dictionary is passed, it returns the number of key values.

Polymorphism in OOP

Let us now study what is polymorphism in classes and how does it turn out to be useful.
Yesterday we saw how the methods with same name are overridden. Polymorphism is something related to functions with the same name. In order to understand what polymorphism is, let us consider the following example.

class ape():
    food=""
    def __init__(self,weight):
        self.weight=weight
    def cry(self):
        pass # Do nothing
    def eat(self):
        print(self.food)

class chimpanzee(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="bananas"
    def cry(self):
        print("I am a chimp")

class gorrilla(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="fruits"
    def cry(self):
        print("I am a gorrilla")

a=chimpanzee(20)
b=chimpanzee(25)
c=gorrilla(50)

a.cry()
b.cry()
c.cry()

print(a.weight)
print(b.weight)
print(c.weight)

a.eat()
b.eat()
c.eat()

I am a chimp
I am a chimp
I am a gorrilla
20
25
50
bananas
bananas
fruits

Study the above example carefully. What we have seen above is an example of polymorphism itself!

Now, chimpanzee and gorilla both derive from the same class- ape. They have same attributes- weight and food. But they have different values for them. We can even add additional methods for each of those classes. But the attributes weight, food, and method eat was derived from the class ape itself. So is there a way to use them without knowing weather the ape is a chimpanzee or a gorilla? This is possible if all of them have same methods (that is overloaded methods.) In other words can we just use their 'apish' characteristics as one by using the methods. This is the central idea behind polymorphism. In Python, Polymorphism is achieved through method overloading.

a is both a ape as well as a chimpanzee. So can we treat a as n ape? so can we treat a, b, c as equal apes? We can using polymorphism. At times, we may need to consider that a,b,c are just apes and not gorillas or chimpanzees and treat them all equally. This decreases the overhead of treating objects of different subclasses species as different entities. For example tomorrow if I want to add an Orangutan subclass, I will not require to go back and change everything I had written earlier. Using Polymorphism I can just treat them as equals. We overload the functions.

Now we can make the polymorphism better by using

class ape():
    food=""
    def __init__(self,weight):
        self.weight=weight
    def cry(self):
        pass # Do nothing
    def eat(self):
        print(self.food)

class chimpanzee(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="bananas"
    def cry(self):
        print("I am a chimp")

class gorrilla(ape):
    def __init__(self,weight):
        super().__init__(weight)
        self.food="fruits"
    def cry(self):
        print("I am a gorrilla")


a=chimpanzee(20)
b=chimpanzee(25)
c=gorrilla(50)

for i in (a,b,c):
 i.cry()
 print(i.weight)
 i.eat()

So friends that was all for today. Let us learn more about Python in the upcoming days.....

Learning Python- Intermediate course: Day 41, Inheritance in Python

Aatmaj — Wed, 13 Oct 2021 04:58:05 +0000

Today we will learn about inheritance in Python

Inheritance

Inheritance provides Code Reusability. We do not need to write the same piece of code again and again for various subclasses. This increases Flexibility of the code. This means that subclasses can be formed without altering the original classes.

The inherited class can use functions and variables of the derived class

Syntax.

Classes can be inherited by passing the name of the superclass to the brackets class inherited(master)

Let us see an example below to demonstrate inheritance in pyuthon

class sample():
 a=2
 b=3
 def fun(self):
     print("Hello world")

class sample2(sample):
    def fun2(self):
        print(self.a+self.b)

mysample2=sample2()
mysample2.fun()
mysample2.fun2()

Hello world
5

Explaination

Here, sample() is the masterclass and sasmple2 is the derived class. The derived class sample2 inherits the master class as we pas the name of the master class into the derived class bracket.

class sample2(): This syntax will create class sample2
class sample2(sample): This syntax will create a class sample2 and make it inherit the class sample

Once the class sample2 inherits sample, it can use it's attributes (like here a and b) in it's body. This is why no errors were generated when we used to variables a and b directly in the function fun2. The values fir a and b were assigned in the master class (sample2 itself ands need not be assigned again . This is an example of code reuse and information hiding

The derived class sample2 can also use the functions declared in the master class. This is how the function fun could be used and run successfully.

I hope you do not have any more doubts, if you have, please feel free to post them in the comments below.

Inheritance of constructors.

Constructors are not inherited by default. The example below will make things very clear

class sample():
 a=2
 b=3
 def __init__(self):
     self.a=100
     self.b=50
 def fun(self):
     print("Hello world")

class sample2(sample):
    def fun2(self):
        print(self.a+self.b)

mysample2=sample2()
mysample2.fun()
mysample2.fun2()

Hello world
5

In the above example, you would expect the output to be 150 and not 5. But it is not so. This is because of the fact the constructors of the master class are not inherited by the derived classes by default. This means that sample2.__init__ is not the same as sample.__init__.

Why? Well remember In the previous parts we learnt that if we do not provide a constructor to the class, Python provides one default constructor automatically? Something similar happened in this case. We did not provide any constructor to the sample2 class. So python made a default blank constructor in it's place, which had no relation to the master class.

If we want to add the constructor, we can use the following syntax-

class sample():
 a=2
 b=3
 def __init__(self):
     self.a=100
     self.b=50
 def fun(self):
     print("Hello world")

class sample2(sample):
    def __init__(self):
     super().__init__()
    def fun2(self):
        print(self.a+self.b)

mysample2=sample2()
mysample2.fun()
mysample2.fun2()

Using the super keyword, we can manage the constructors.

Note, even though constructors are not inherited, the arguments of the constructors in both the classes must match. Example shown below

class sample():
 a=2
 b=3
 def __init__(self,var):
     self.a=100
     self.b=50
 def fun(self):
     print("Hello world")

class sample2(sample):
    def fun2(self):
        print(self.a+self.b)

mysample2=sample2()
mysample2.fun()
mysample2.fun2()

Traceback (most recent call last):
  File "main.py", line 14, in <module>
    mysample2=sample2()
TypeError: __init__() missing 1 required positional argument: 'var'

...

class sample():
 a=2
 b=3
 def __init__(self,var):
     self.a=100
     self.b=50
 def fun(self):
     print("Hello world")

class sample2(sample):
    def fun2(self):
        print(self.a+self.b)

mysample2=sample2(3)
mysample2.fun()
mysample2.fun2()

Hello world
150

Exercise What is the output of the following program? and why?

class sample():
 a=2
 b=3
 def __init__(self):
     self.a=100
     self.b=50
 def fun(self):
     print("Hello world")

class sample2(sample):
    def __init__(self):
     a=100
     b=200
    def fun2(self):
        print(self.a+self.b)

mysample2=sample2()
mysample2.fun()
mysample2.fun2()

Solution-
The output is

Hello world
5

This is because self.a=100 and self.b=200 should haver been written in place of a=100 and b=200

Function overloading in Python

What if two functions have the same name in the master class as well as the derived class? Well the answer is simple the function in the derived class will be considered.
This is know as function overloading.

class sample():
 a=2
 b=3
 def __init__(self):
     self.a=100
     self.b=50
 def fun(self):
     print("Hello world")


class sample2(sample):
    def __init__(self):
     super().__init__()
    def fun(self):
        print(self.a+self.b)

mysample2=sample2()
mysample2.fun()

If we want to use the function in the previous function, then use the super syntax again.

class sample():
 a=2
 b=3
 def __init__(self):
     self.a=100
     self.b=50
 def fun(self):
     print("Hello world")


class sample2(sample):
    def __init__(self):
     super().__init__()
    def fun(self):
        super().fun()
        print(self.a+self.b)

mysample2=sample2()
mysample2.fun()

Hello world
150

So friends that was all for today. Thank you and hope you are enjoying....

Spiral lifecycle model Part 1

Aatmaj — Mon, 11 Oct 2021 12:39:34 +0000

The spiral model of development is a really good model that helps you develop faster. In the spiral model, you start small and expand the scope of the project in increments. You expand the scope only after you have reduced the risks for the next increment to an acceptable level. Today let us learn more about this model

The spiral model is a risk oriented model that breaks a software project up into mini projects. Each mini-project addresses one or more major risks until al the major risks have been addressed.
Risks refers to factors like

Poorly understood requirements
Poorly understood architecture
Potential requirement problems
Problems in underlying technology.

After all the risks have been addressed, the waterfall model terminates as a waterfall lifecycle would.

The spiral model is also called as the 'cinnamon roll' model.

the basic idea about the diagram is that you start on a small scale in the middle of the spine, explore the risks make a plan to handle the risks, and then commit to an approach for the next iteration.

Each iteration moves the project into a larger scale. You roll up one layer of the cinnamon roll, check to be sure that it's what's you wanted., and then you begin work for the next layer.

Each iteration involves the six steps below

Determine objectives, alternatives, and constraints.
identify and resolve risks
Evaluate alternatives
Plan the next iteration.
Commit to an approach for the next iteration.

In the spiral model, the early decisions are the cheapest. You spend less developing the concept of operation than you do developing the requirements than you do developing the design, implementing the product, and testing it.

You can tailor the iterations of the model as per your requirements and the needs of the project.

Notes and images from Rapid Development: Taming Wild Software Schedules by Steve McConnell

To be continued...

Learning Python- Intermediate course: Day 40, Summary of the week and more about OOP

Aatmaj — Sat, 09 Oct 2021 04:31:10 +0000

Today let us summarize the week and check out a more about OOP

Let us first check out a program which shows the implementation of Complex numbers through classes

class Complex:
    #Default values
    x=0
    y=0 

    def __init__(self,x,y):
        self.x=x
        self.y=y
    def absolute(self):
        return (self.x**2+self.y**2)**0.5

a=Complex(2,-3)
print(a.absolute())
b=Complex(4,5)
print(b.absolute())

3.605551275463989
6.4031242374328485

In the above program, a and b are different objects of the same class. Which means that they have different values of attributes. Object is representative of class. Consider it like this - class is a common noun while the object is a proper noun. Classes are like templated for molding objects.

Why OOP?
In software development lifecycle, coding is fifth or sixth stage. First analysis of requirements of clients is done. Developers approach client and get technical review of the requirement, discuss at length with client. Unless we get clarity as what and how is expected coding doesnt start. Then feasibility test is done. budget-wise. then prototype is given to client step by step. Changes are noted.
In this whole process, the use of OOP is beneficial. Maintaining, updating and carry forward existing versions to next version can be done easily using OOP. Code flexibility is enhanced. We can make changes to the project without much changes in code using OOP. Also, extension of code becomes very easy. We can add new features without much changes to the old ones. This is why in a popular language like Python, learning about OOP is important.

Summary of the week.

Day 37

We learnt about file handling in Python.
We can open a file into four modes

"r" Reading mode
"w" Writing mode
"a" Appending mode
"r+" Both reading and writing If not passed, then Python will assume it to be “ r ” by default. file = open("myfile.txt", "r") Opens the file. We can read the contents of the file using the file.read() method. We can write into a file using the file.write("\n") method.

Day 38

We learnt about making classes in Python. Classes are object blueprints. Classes are generated using the syntax

def functionname (classname,......arguments......):
 ...
 ...
 ...

In the class methods, the class parameter (self) is a must. Private methods can be made by writing two underscores before the class name. Private methods cannot be accessed from outside the class.

Day 39

Constructors in Python can be created using the __init__ keyword. A constructor is a special type of member function of a class which initializes objects of a class. The constructor is run when the class is instantiated. The class constructors can be called by other parts of the class or even outside pf the class. If we do not provide a constructor to the class, Python generates one default constructor automatically. We can even pass parameters to the constructors.

So friends that was all for today!
Next week plan-

Inheritance
Polymorphism
Deadly Diamond of death

DEV Community: Aatmaj

Cool Github repositories for Everyone

📒 Useful repositories for every developer!!

Dont forget to star the Original github repo 🤩

Table of contents

Data structures

Machine learning

Math

Flutter and App dev

IOT

University

Interview prep

CP

IOS

Blockchain

Cloud computing

Web dev

Security

Languageresources questions and cheatsheets

Data base

cheatsheets

Awesome github repositories

git

Others

🤝 Help grow the community

5 proverbs for rapid development

Let us see five proverbs which fit perfectly to the rapid development scenario.

An ounce of protection is worth a pound of cure.

A stich in time saves nine

Cross the stream where it is shallowest.

Watch the doughnut, and not the hole.

Too many cooks spoil the broth.

Waterfall with subprojects

The main risk

Sashimi Waterfall model of development

Sashimi Waterfall model of development

The disadvantages.

Learning Python Intermediate Course- yearning for suggestions

Spiral lifecycle model Part 2

Advantages of the model

Disadvantages

When to use this model

For medium to high-risk projects.

When there is adequate to fair time.

Learning Python- Intermediate course: Day 44, Summary of the week, examples and exercises

Today we will have a quick summary of the week

Exercises-

1) Correct the following code

2) Correct the following code

3) Extend the above program to include a class tiger and class wild. Add attribute habitat to wild and pet. Use iterable for in loop to call out the methods (hint use try except)

Day 41

Day 42

Day 43

Intermediate part of the course ends today.

Learning Python- Intermediate course: Day 43, DDD and more on OOP

Today we will cover some OOP properties that are not covered in Python and look at how Python resolves the Deadly Diamond of Death.

Interfaces

Duck typing in Python

Multiple inheritance in Python

Deadly Diamond of Death

Abstract classes

abc module

Learning Python- Intermediate course: Day 42, Polymorphism.

Today we will learn about Polymorphism in Python

What exactly is Polymorphism

Polymorphism in operators

Polymorphism in functions

Polymorphism in OOP

Learning Python- Intermediate course: Day 41, Inheritance in Python

Today we will learn about inheritance in Python

Inheritance

Syntax.

Explaination

Inheritance of constructors.

Function overloading in Python

Spiral lifecycle model Part 1

Learning Python- Intermediate course: Day 40, Summary of the week and more about OOP

Today let us summarize the week and check out a more about OOP

Summary of the week.

Day 37