Share
Embed
Recro Webinar Nov 28, 2020 : Progressing towards responsible Software Craftsmanship
Hitesh Das
November 28, 2020
Transcript
45 slides
-
Progressing towards responsible Software Craftsmanship Hitesh Das Webinar . Recro
. Saturday, 28th Nov 2020 -
Why do software projects continue to fail? - Poor Planning?
- Poor Requirements? - Poor Management? UNCONTROLLED COMPLEXITY -
TECHNICAL DEBT Defects No Reuse Rewrites Afraid to Change Increase
Development times -
Introduction Why is it the need of the hour? Building
the Craftsman Mindset -
Not only working software, but also well-crafted software - Write
code supported with tests - Code should speak the Business Language. - Simple Design (≠ No Design) -
Not only responding to change, but also steadily adding value
- Code we write should be Testable - It should be Extendable for incremental value addition - Refactor for optimization THE BOY SCOUTS HAVE A RULE: “Always leave the campground cleaner than you found it.” -
Not only individuals and interactions, but also a community of
professionals - Share/Mentor Knowledge - Discuss and propose Ideas - Share Success & Failures - Community engagements. Inspire and ignite the same passion with peers. -
Not only customer collaboration, but also productive partnerships - Must
help our clients. - Must say “NO” for client’s benefit. - Cultivate productive. partnerships. - Find a way to ensure engagement quality. -
Introduction Why is it the need of the hour? Building
the Craftsman Mindset How to progress? -
Why Is It So Important? Architecture is a primary element
in the design and planning phase of software development. A software project without architecture can be compared to building without foundations - the bigger the building, the more problems this will cause. -
We often see an approach without architecture as faster. However,
very soon it turns out to be a dead end. Often it is too late to add architecture or patterns to such code. Along with the increase of size and complexity of the project, these problems accumulate. Courtesy : The Agile Samurai (Book) -
We should not build fighter jets to buy groceries from
the mart on the opposite road -
Layered architecture The advantage of a layered architecture is the
separation of concerns, which means that each layer can focus solely on its role. This makes it: • Maintainable • Testable • Easy to assign separate "roles" • Easy to update and enhance layers separately -
Event Driven architecture Many programs spend most of their time
waiting for something to happen (basically an event). This is especially true for systems that work directly with humans. Event-driven architectures: • Are easily adaptable to complex, often chaotic environments • Scale easily • Are easily extendable when new event types appear -
Service Oriented Architecture The Service Oriented/Microservice/Microkernel architecture pattern is useful
when your software system or product contains many integration points to external entities. This architecture pattern can be identified as a plug-in based pattern and it consists of two main components, the core system and plug-in components. Microservices are an approach to software architecture, where the product is split into decoupled components that interact with each other via APIs, ensuring the continuity of product performance. -
Service Oriented Architecture Platform Independence Easier to Test, More Reliable
Ability to Reuse Codes Parallel Development Scalability Most often consider adopting microservices for a product that has been in production for quite some time and has become too bulky to be updated and maintained as a monolith. By splitting it to decoupled microservices, the developers want to: Improve the system resilience, as any part of the product can be rebooted separately. Decrease the development complexity, as many functions can be isolated to reduce the number of obligatory interactions. Shorten the time-to-market for new features, as developing a new version of a smaller module is faster than updating the product as a whole. -
- Cost - Time to Market - Number of users
(current and future) - Level of independence (Integration with other systems) Motivation while choosing the architecture -
SOLID Principles 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) -
DRY – Don’t Repeat Yourself "Every piece of knowledge or
logic must have a single, unambiguous representation within a system." - Divide your system into pieces. Divide your code and logic into smaller reusable units and use that code by calling it where you want. - Don't write lengthy methods, but divide logic and try to use the existing piece in your method. Less code is always good :) -
KISS – Keep it Simple Stupid - Keep coding simple
and straightforward. - Keep your methods small. Each method should never be more than 40-50 lines. - Each method should only solve one small problem, not many use cases. - If you have a lot of conditions in the method, break these out into smaller methods. Easier to read and maintain. - It can help find bugs a lot faster -
YAGNI – You Aren’t Going to Need It - Often
used generally in agile software teams. - It's a statement that some capability we presume our software needs in the future should not be built now because "you aren't gonna need it". -
The Triangulation Test Driven Development(TDD) TDD is primarily a developer's
tool to help create well-written unit of code (function, class, or module) that correctly performs a set of operations -
... If you want to develop software with pride and
professionalism; love what you do and do it with excellence; and build a career with autonomy, mastery, and purpose, it starts with the recognition that you are a craftsman. Once you embrace this powerful mindset, you can achieve unprecedented levels of technical excellence and customer satisfaction.” -- The Software Craftsman: Professionalism, Pragmatism, Pride by Sandro Mancuso -
References http://blog.cleancoder.com/ https://techbeacon.com/ http://manifesto.softwarecraftsmanship.org/ https://www.netguru.com/blog https://er.yuvayana.org/quality-software-attributes- characteristics-of-good-software-products/ https://www.mindtree.com/about/resources/manifes to-software-craftsmanship-and-four-dimensions-qual ity
https://martinfowler.com/ https://agilemanifesto.org/ -
Hitesh Das (HD) Progressing towards a Software Craftsman Medium [email protected]
+91-9015225032 @hiteshdas1912 @hiteshdas - - -