I was working on Raspberry Pi for some of my projects and getting some interesting problem statements those can be easily addressed by Internet of Things. So, Here I started exploring Estimote http://estimote.com will be starting cooking on interesting problems and keep posting regularly here 😉
While our interview process we ask Questions on Design Patterns and most of the Candidates are only aware of MVC Design Pattern. I’m writing this post influenced from Book Design Patterns, Elements of Reusable Object-Oriented Software
There are lots of Definitions of Design Patterns on internet but Christopher Alexander says, “Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it in the same way twice”
In simplest way “A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design“.
In general, a pattern has four essencial elements:
- Pattern Name
The pattern name is a handle we can use to describe a design problem, its solutions, and consequences in a word or two.
- Naming a pattern immediately increases the design vocabulary. It lets us design at a higher level of abstraction.
- Having a vocabulary for patterns lets us talk about them.
- It makes it easier to think about designs and to communicate them and their trade-offs to others.
The problem describes when to apply the pattern.
- It explains the problem and its context.
- It might describe specific design problems such as how to represent algorithms as objects.
- It might describe class or object structures that are symptomatic of an inflexible design.
- Sometimes the problem will include a list of conditions that must be met before it makes sense to apply the pattern.
The solution describes the elements that make up the design, their relationships, responsibilities, and collaborations.
- The solution doesn’t describe a particular concrete design or implementation, because a pattern is like a template that can be applied in many different situations.
- Instead, the pattern provides an abstract description of a design problem and how a general arrangement of elements (classes and objects in our case) solves it.
The consequences are the results and trade-offs of applying the pattern.
- The consequences for software often concern space and time trade-offs.
- They may address language and implementation issues as well.
- Since reuse is often a factor in object-oriented design, the consequences of a pattern include its impact on a system’s flexibility, extensibility, or portability.
- Listing these consequences explicitly helps you understand and evaluate them
As per Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides in their Design Patterns book, you can divide Design Patterns into three types:
- Creational patterns are ones that create objects for you, rather than having you instantiate objects directly. This gives your program more flexibility in deciding which objects need to be created for a given case.
- Structural patterns help you compose groups of objects into larger structures, such as complex user interfaces or accounting data.
- Behavioral patterns help you define the communication between objects in your system and how the flow is controlled in a complex program.
I studied following link for Design Pattern implementations in PHP and I assume these are must read for everyone writing code in PHP and in OOPs way.
I would love to participate in healthy discussion on these.
*Credits to Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides.
The term ‘agile‘ is a philosophy and is a conceptual framework for undertaking software engineering projects. Most agile methods attempt to minimize risk by developing software in short time boxes, called iterations. Each iteration is like a miniature software project of its own, and includes all of the tasks necessary to release the mini increment of new functionality: planning, requirements, analysis, design, coding, testing, and documentation. While an iteration may not add enough functionality to warrant releasing the product, an agile software project intends to be capable of releasing new software at the end of every iteration.
Agile software development refers to a group of software development methodologies that are based on similar principles. Agile methodologies generally promote: A project management process that encourages frequent inspection and adaptation; a leadership philosophy that encourages team work, self-organization and accountability; a set of engineering best practices that allow for rapid delivery of high-quality software; and a business approach that aligns development with customer needs and company goals.
Agile Software development lay stress on:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
Some of the well-known agile software development methods:
- Agile Modeling
- Agile Unified Process (AUP)
- Agile Data Method
- Essential Unified Process (EssUP)
- Extreme programming (XP)
- Feature Driven Development (FDD)
- Getting Real
- Open Unified Process (OpenUP)
Here are some Characteristics of Agile Methodologies:
– Iterative with short cycles enabling fast verification and corrections.
– Time bound Iteration cycles (Daily, Weekly and monthly).
– Modularity at development process level.
– People oriented.
– Collaborative and communicative working style
– Incremental and convergent approach that minimize the risk and facilitate functional additions.
We will discuss Agile Methodologies and Compare with traditional Software Development methods one by one in upcoming posts. Stay tuned 😉 .