Get ready with Application Frameworks
Application frameworks is one of the main module under the Software Engineering specialization at SLIIT campus. This module gives us overall idea about how to become a full stack developer. In this module first lectures covers SOLID principle, some guidelines and software engineering practices.
SOLID are 5 object oriented principles that follow when design a software. They are Single responsibility, Open-close, Liskov substitution, Interface segregation and Dependency inversion.
Single responsibility means having one particular define responsibility at any given level. If you think about a class as long as that class does one thing because of that it is very easy to maintain. If it is doing one thing that it supposed to do there is only one reason for it to change.
Secondly Open-Close principle means open for extension and closed for modifications. When you are defining a class or a method you are closing it for modifications anyone wants to add more features to it be simply need to extend it rather than modify.
Third one is Liskov substitution that means every subclass/derived class should be able to substitute their parent/base class. Child is actually doing what parent is supposed to do with some extra with that given boundary not anything like totally different.
Interface segregation principle means clients should not be forced to implement methods they do not use, basically you have to break your interfaces based on the usage.
Last one is Dependency inversion that typically means higher level modules depends on the business itself. But the lower level modules (DB classes, presentation classes, APIs … ) should depend on these business level modules.
Then we can move to approaching the solution and implementing the solution. We can achieve the solution using Think throughout the problem, Divide and conquer, KISS, Learn specially from mistakes, Always remember why software exists and remember that you are not the user.
When we implementing the solution we follow some guidelines. They are YAGNI, DRY, Embrace abstraction, DRITW, Write code that does one thing well, Debugging is harder than writing code and Kaizen.
Practices are set of guidelines that we should follow when we are developing code. Mainly we have to consider unit testing, code quality, code review, version controlling and continuous integration.
Unit testing is basically pick a unit, unit may be method, class, or API like it could be anything but that boundary clearly defined. Unit test is while we develop the unit we write unit test to test the behavior of the unit. Unit test allow you to find bugs as early as possible.
Code quality means follow the relevant coding standards for relevant programming languages. Our code should be understandable, readable and easily maintainable. Organizations can impose some rules that all the code that is produce from the developers is kind of like a similar manner.
Code review we can use for improve the code. Another developer is looking into another developer’s code with the intension of improving the code.
We can manage and develop our code easily using version controlling. Currently GitHub is one of the main version controlling platform in the industry. Lots of organizations are used that for maintain deferent versions of code and work with multiple developers easily. Also we can maintain code history without losing code portions.
Finally continuously integrate your code in the main branch make sure work as expected. This allows developers to detect issues early.