DEV Community: Ibrahim Raimi

The Ultimate Guide to Agile Software Development

Ibrahim Raimi — Sun, 07 May 2023 19:20:03 +0000

Overview

Agile software development methodology has gained immense popularity over the years due to its ability to quickly and efficiently produce software. It is a lightweight and flexible approach to software development that focuses on delivering incremental and interactive results through collaboration, adaptive planning, short delivery times and customer feedback.

What is Agile Software Development

Agile software development is a project management approach that emphasizes flexibility, collaboration, and iterative development to deliver software products that meet customer needs.

Agile software development eliminates the risk of investing months or years in a development process that may ultimately fail due to minor errors made in the early stages. It depends on placing trust in employees and teams to work closely with customers, comprehend the objectives, and offer solutions quickly and incrementally. Here's a quick summary of how agile software development operates:

Planning and Requirements Gathering: The team works with the customer to understand the project requirements and create a prioritized backlog of user stories.
Sprint Planning: The team selects a set of user stories from the backlog for the upcoming sprint and creates a sprint plan. The sprint plan outlines the specific tasks that need to be completed during the sprint.
Development: The team works on the selected user stories during the sprint, using an iterative development process. This means that the team releases working software at the end of each sprint.
Daily Stand-up Meetings: The team holds brief daily meetings to discuss progress and any issues that need to be addressed.
Sprint Review: At the end of each sprint, the team presents the working software to the customer for feedback.
Sprint Retrospective: The team reflects on the completed sprint and identifies areas for improvement. The team also use this information to adjust their approach for the next sprint.
Repeat: The team continues to work through the backlog of user stories, selecting and completing them in sprints until the product is complete.

The 3C's of Agile Software Development

Agile software development is based on the principles of collaboration, customer feedback, and the “three C’s” – card, conversation, and confirmation.

Card

A card in user stories in Agile is a way of breaking down user stories into smaller, more manageable tasks that can be easily monitored and identified. Each card may include additional information such as priority level or estimated completion date for further support of project management. By breaking down the stories into individual cards, developers can focus on one specific aspect at a time, making tracking progress easier and identifying any potential changes or issues before they become problems during development.

Conversation

The second C of Agile is a conversation, which emphasizes frequent communication between team members to identify any possible changes or issues before they become problems during development. This involves regularly discussing progress updates with stakeholders and providing feedback for any feature requests or bug reports to ensure the final product meets all quality assurance standards required by the customer.

Confirmation

Finally, the third C of Agile is confirmation, which allows customers to review and test features before making them available in production environments. This helps to ensure applications are error-free while also giving developers valuable insights into customer preferences so they can make necessary improvements before release.

Example of Agile Software Development

The most popular and common example of agile software development is Scrum.

Scrum is a software product development strategy that organizes software developers as a team to reach a common goal — creating a ready-for-market product.

How Scrum works

A product owner makes a prioritized wish list known as a product backlog.
The scrum team takes one small piece of the top of the wish list called a sprint backlog and plans to implement it.
The team completes their sprint backlog task in a sprint (a 2-4 week period). They assess progress in a meeting called a daily scrum.
The ScrumMaster keeps the team focused on the goal.
At the sprint’s end, the work is ready to ship or show. The team closes the sprint with a review, then starts a new sprint.

In layman's terms

Grace meets with a customer to discuss her company’s needs. Those needs are the product backlog. Grace chooses the most important tasks to work on in the next two weeks. Her team meets in a daily scrum to target work for the day ahead and address roadblocks. At the end of the sprint, Grace delivers the work, reviews the backlog, and sets the goal for the next sprint. The cycle repeats until the software is complete.

Benefits of Agile Software Development

The benefits of Agile are tied directly to its faster, lighter, more engaged mindset. The process delivers what the customer wants, when they want it. There’s much less wasted time spent developing in the wrong direction, and the entire system is quicker to respond to changes.

It's Faster: Speed is one of the biggest benefits of Agile Methodology. A faster software development life cycle means less time between paying and getting paid. That, in turn, means a more profitable business.
Increased customer satisfaction: With Agile, customers don’t wait for months or years, only to get exactly what they didn’t want. Instead, they get iterations of something very close to what they want, very fast. The system adjusts quickly to refine the successful customer solution, adapting as it goes to changes in the overall environment.
Values employees: Employees whose ideas are valued are vastly more productive than those who are ordered to follow a set of rules. The Agile Methodology respects employees by giving them the goal, then trusting them to reach it. Since they’re the ones with their hands on the controls and the ones who see the obstacles that crop up every day, employees are in the best position to respond to challenges and meet the goals at hand.
Eliminates rework: By involving the customer at more than just the phases of requirements and delivery, the project remains on-task and in-tune with customer needs at every step. This means less backtracking and less “out on a limb” time between the time we do the work and the time the customer suggests revisions.

Best Practices for Agile Software Development

Focus on the customer: Agile development puts the customer at the center of the development process, so it's important to understand their needs, preferences, and expectations. Regular communication with the customer throughout the development process helps to ensure that the software product meets their
requirements.
Prioritize user stories: User stories are short, simple descriptions of a feature or functionality from the user's perspective. Prioritizing user stories helps the team to focus on the most important features first and to deliver working software more quickly.
Use sprints to manage development: Sprints are time-boxed periods of development where the team focuses on a specific set of user stories. Using sprints helps the team to manage development in a predictable and controlled way and to deliver working software at regular intervals.
Foster collaboration: Agile development emphasizes teamwork and collaboration. Encouraging collaboration between team members, including developers, testers, and business analysts, helps to ensure that everyone is working towards a common goal.
Embrace change: Agile development recognizes that change is inevitable and that requirements may evolve throughout the development process. Embracing change and being flexible allows the team to adapt to new requirements and to deliver software that meets the customer's changing needs.
Continuously improve: Agile development is a continuous improvement process, so it's important to regularly reflect on the development process and identify areas for improvement. This helps the team to become more efficient and effective in delivering working software.

Agile Methodology Tools

Here are three tools that can aid you and your team in enhancing your Agile software development procedure.

ActiveCollab: An affordable tool for small businesses, ActiveCollab is easy to use. This software development aid requires little training and provides excellent support.
Atlassian Jira: This powerful project management tool facilitates development by incorporating Scrum, Kanban, and customizable workflows.
Pivotal Tracker: This methodology tool is geared specifically for mobile projects. A little jargon-heavy, it’s user-friendly after a brief orientation period.

Congratulations on reaching this point! Let's review the main points of Agile Software Development: continuously plan and collaborate; involve users in the process; develop in iterations; continuously test and integrate; hold retrospective meetings; and aim for a Minimal Viable Product. To overcome challenges, prioritize communication, stakeholder involvement, and a willingness to embrace change. By adopting the Agile methodology, you can achieve faster time-to-market, increased flexibility, transparency, and improved quality.

I look forward to connecting with you in the next blog post. Until then, keep developing and solving problems.

10 GitHub Learning Repositories for Beginner Developers

Ibrahim Raimi — Tue, 04 Apr 2023 14:02:02 +0000

It can be challenging for a beginner developer to know where to begin when learning to code. Fortunately, GitHub has a variety of learning repositories to aid in your initial learning.

We'll introduce 10 GitHub learning repositories for beginner developers in this article.

You will find knowledge about the general web, learning roadmaps, computer science principles, interview preparation guides, additional books and websites to use and so much more.

1. how-web-works

What happens behind the scenes when we type www.google.com

⭐ GitHub stars 13k

2. developer-roadmaps

Community driven roadmaps, articles and resources for developers

⭐ GitHub stars 236K

3. Free-Software-Books

List of Free Learning Books and Resources for Developers

⭐ GitHub stars 92

4. ossu-computer-science

Path to a free self-taught education in Computer Science!

⭐ GitHub stars 137k

5. coding-interview-university

⭐ GitHub stars 253k

6. freecodecamp

A friendly community where everyone can learn to code for free.

⭐ GitHub stars 364k

7. project-based-learning

A list of programming tutorials in which aspiring software developers learn how to build an application from scratch.

⭐ GitHub stars 96k

8. javascript-algorithms

This repository contains JavaScript based examples of many popular algorithms and data structures.

⭐ GitHub stars 166k

9. system-design-primer

Learn how to design large-scale systems. Prep for the system design interview.

⭐ GitHub stars 216k

10. front-end-interview-handbook

Learn how to design large-scale systems. Prep for the system design interview.

⭐ GitHub stars 37k

In conclusion, GitHub is a great platform for inexperienced developers who want to brush up on their coding skills and acquire new ones. The ten repositories we've examined in this piece are just a portion of the extensive library of materials on GitHub. Everyone can find something on GitHub to learn, whether they want to study web development, computer science, or a specific programming language. Therefore, get investigating and have fun learning!

JavaScript Package Managers: NPM, YARN And PNPM

Ibrahim Raimi — Tue, 28 Mar 2023 08:08:59 +0000

JavaScript has become one of the most popular programming languages in the world, powering everything from web applications to mobile apps and even desktop applications. As a result, the JavaScript ecosystem has grown rapidly, and developers now have access to a wide range of tools and libraries that can help them build more robust and efficient applications. However, managing these tools and libraries can be a challenge, which is why package managers have become an essential part of the JavaScript developer's toolkit.

In this article, we will take a closer look at three of the most popular JavaScript package managers: NPM, Yarn, and PNPM.

What is a Package Manager

A package manager is a tool that automates the process of installing, updating, and managing software packages. In the context of JavaScript, packages are libraries or modules that developers use in their applications. Package managers help developers to manage these packages by providing a centralized repository where packages can be stored, versioned, and downloaded as needed.

They do this by storing packages in a central location on the hard disk or network drive.

NPM

NPM (short for Node Package Manager) is the default package manager for Nodejs applications. It was first released in 2010 and has since become the most popular package manager in the JavaScript ecosystem. NPM is known for its simplicity and ease of use, making it an ideal choice for beginners.

One of the key features of NPM is its ability to handle dependencies efficiently. When you install a package using NPM, it automatically installs all the packages that the installed package depends on, recursively. This means that you don't have to worry about manually installing dependencies, which can save a lot of time and effort.

Yarn

Yarn is a relatively new package manager, having been released by Meta aka Facebook in 2016. It was designed to address some of the performance and reliability issues that developers were experiencing with NPM. Yarn is built on top of the same package registry as NPM, so it can use the same packages.

One of the key features of Yarn is its speed. Yarn uses a parallel installation process, which means that it can install packages much faster than NPM. Additionally, Yarn has a caching system that stores packages locally, so you don't have to download them again if you need to reinstall them.

Yarn also has some additional features that NPM does not have, such as the ability to install packages in a deterministic way. This means that when you install a package, you will always get the same version of that package, regardless of when you install it or which machine you install it on.

PNPM

PNPM (short for Performant NPM) is a relatively new package manager that was first released in 2016. It was designed to be a faster alternative to NPM and Yarn, with a focus on performance and disk space usage.

Like Yarn, PNPM uses parallel installation, which allows it to install packages faster than NPM. However, PNPM takes this a step further by using a single shared folder to store all package dependencies for all projects on a machine. This reduces disk space usage and also speeds up subsequent installations by reusing previously installed packages.

PNPM also lets you install multiple versions of a package simultaneously, which is helpful for projects with conflicting dependencies.

NPM, Yarn and PNPM Comparison

Package Installation Speed

One of the most important factors to consider when choosing a package manager is its installation speed. Yarn and PNPM both use parallel installation to download packages simultaneously, which can be significantly faster than NPM's sequential installation.
PNPM is usually the fastest among the three, as it uses a single shared folder to store all package dependencies for all projects on a machine. Yarn comes in second, with NPM being the slowest of the three.

Package Version Management

Package version management is another crucial factor to consider when choosing a package manager. All three package managers use a package.json file to keep track of project dependencies and versions, but Yarn and PNPM both generate a yarn.lock and pnpm-lock.yaml file respectively, which ensures that the same package versions are used across all machines. NPM does not generate a lock file by default, but it can be enabled by using the --save-exact flag.

Dependency Management

Managing dependencies can be quite challenging in large-scale projects with multiple dependencies. NPM, Yarn, and PNPM all have different ways of handling dependencies. NPM has a flat dependency structure, which means that it installs all dependencies in the node_modules folder at the root level. Yarn and PNPM both use a nested dependency structure, which installs dependencies in a tree-like structure within the node_modules folder.

PNPM takes this further by using a single shared folder to store all package dependencies for all projects on a machine, which can significantly reduce disk space usage.

Cache Management

All three package managers use a caching system to speed up subsequent installations by reusing previously downloaded packages. Yarn and PNPM both have more advanced caching mechanisms than NPM. Yarn's caching mechanism can be managed using the yarn cache command, while PNPM's caching mechanism is built into its single shared folder structure.

Community Support

NPM has the largest package repository of the three, with over 1.5 million packages available for download. It also has a large and active community, which can be a great resource for troubleshooting and support. Yarn has a smaller package repository, but it is growing steadily, and it is backed by Facebook aka Meta, which provides strong community support. PNPM has a smaller community and package repository than NPM and Yarn, but it is actively maintained and has gained a lot of popularity in recent years.

Conclusion

To summarize, there are three popular JavaScript package managers: NPM, Yarn, and PNPM. Each has its own advantages and disadvantages. NPM is the most popular and has the biggest package repository, but can sometimes be slow. Yarn is faster than NPM and has parallel installation and deterministic dependency resolution. PNPM is the fastest and uses less disk space.

The package manager you choose will depend on what you need. Each one has its own features and drawbacks, so it's important to consider them carefully before deciding.

Data fetching in React with SWR

Ibrahim Raimi — Fri, 03 Feb 2023 14:34:35 +0000

What is SWR?

Usually, when we make a fetch request, we use the native fetch or a third-party library like axios. The browser then makes an HTTP call and accepts a response. While the call is being made, the user waits, usually staring at a loading indicator.

SWR enhances data fetching with caching, revalidation, and request deduplication. The name "SWR" is derived from stale-while-revalidate, an HTTP cache invalidation strategy. It exposes React hooks that we can use for data fetching in our applications.

Why use SWR instead of fetch or axios?

When we use SWR for data fetching, it returns the data from the cache (stale), then sends the request (revalidate) and returns the up-to-date data. SWR will automatically cache the response the first time we fetch it.

With just one single line of code, you can simplify the logic of data fetching in your project, and also have all these amazing features out-of-the-box:

Fast, lightweight, and reusable data fetching
Built-in cache and request deduplication
Real-time experience
Transport and protocol agnostic
SSR / ISR / SSG support
TypeScript ready
React Native

SWR has you covered in all aspects of speed, correctness, and stability to help you build better experiences:

Fast page navigation
Polling on interval
Data dependency
Revalidation on focus
Revalidation on network recovery
Local mutation (Optimistic UI)
Smart error retry
Pagination and scroll position recovery
React Suspense

Getting Started

Installation

yarn add swr

npm install swr

For normal RESTful API with JSON data, you first need to create a fetcher function, which is just a wrapper of the native fetch:

const fetcher = (...args) => fetch(...args).then(res => res.json())

You can also use axios in you fetcher function:

const fetcher = url => axios.get(url).then(res => res.data)

Why do we still need fetch or axios when using SWR?

SWR does not replace native fetch or axios. We'll always need them because SWR only wraps around them. And one of the arguments we pass to the useSWR hook is the fetcher function that uses fetch or axios.

Now we can import the useSWR hook and start using it inside any function components:

import useSWR from "swr"

const Profile = () => {
  const {data, error, isLoading} = useSWR("/api/users/123", fetcher)

  if (error) return <div>Failed to load profile</div>
  if (isLoading) return <div>Loading...</div>

  // render data
  return (
      <div>{data.name}</div>
  )
}

NOTE: We have 3 possible states of a request: loading, ready, or error.
We use the value of data, error, and isLoading to determine these states and return the corresponding UI.

Make it Reusable

The real power of using SWR shows when you can reuse data fetching code. When building an application, we might need to reuse the data we fetch in multiple places. SWR makes it incredibly easy to create custom data-fetching hooks that we can use in any of our components.

export const useUser = (userId) => {
    const { data, error } = useSWR(`/api/users/${userId}`, fetcher)
    return {
        user: data?.user,
        isLoading: !error && !data,
        isError: error
    }
}

Now we can use it in any component like this:

const Profile = ({ userId }) => {
  const { user, isLoading, isError } = useUser(userId)

  if (isLoading) return <div>Loading...</div>
  if (isError) return <div>An error occurred...</div>

  return (
    <div>
          <img src={user.avatar} />
          <span>{user.name}</span>
          <span>{user. Email}</span>
    </div>
)
}

SWR is a better way to fetch data in our React applications. It abstracts away many features that we normally would have written ourselves if our application requires them. It also gives us good defaults so we don't have to spend a lot of time in configuration. Most important of all, it has a simple API and is easy to use.
For more information on SWR, check out the official documentation

There is also an alternative to SWR called react-query which I haven't used, yet. I'll cover that in a future post. I hope you enjoyed this post. Have you used SWR before or have any questions about SWR? Let me know in the comments.

Until next time, peace ✌️

How to increase developer productivity

Ibrahim Raimi — Thu, 12 Jan 2023 23:19:58 +0000

Improving developer productivity can pay dividends - personally and professionally. Every developer encounters productivity challenges in their career, which can accumulate into bigger issues.

Improving your productivity helps with more than just your day-to-day tasks. To enhance your productivity, consider how productive you are now. look for opportunities to improve and decide how you want to reach your productivity goals.

Why does developer productivity matter

Ultimately, programmer productivity matters because developers thrive and enjoy their jobs when they're productive. And productivity allows you to accomplish more and reach for bigger, more ambitious goals.

Without strong productivity, projects may lag behind and team members may be more susceptible to early burnout and frustration. Productive, happy teams have a certain dynamism that propels organizations forward. These are often the teams that attract the best talent and inspire the next big ideas.

What causes lack of productivity among developers

You may have your own list of areas you want to improve on, but productivity challenges generally fall into these areas for engineers:

Unclear or nonexistent benchmarks: When the goal isn't clear, no one knows how to measure developer productivity for the project, or there aren't enough benchmarks, your team may lag or lack sufficient motivation.
Communication woes: Misunderstanding, unmet expectations, insufficient communication, and other communication challenges can strain a team's coding productivity.
Burnout: A common challenge for engineers, burnout is a real possibility for devs who experience stress, don't practice self-care, or struggle with other productivity areas. No one wants to experience burnout. Prevention is key.
Bad habits: Sometimes, we all practice habits that aren't helping our productivity. If you're a manager, you may recognize bad habits in your team members, but tread carefully to encourage successful change.
Lack of cooperation among team members: If one team member cooperates with another, productivity may increase. On the other hand, if one doesn't cooperate with others, productivity decreases.
Lack of awareness: A developer on your team may not know there's a better, more productive way to work.
Lack of employee training: Training helps an employee to increase his productivity. Lack of training is one of the causes of poor productivity.
Lack of favorable environmental conditions: If the environmental condition of the organization is not good, then the productivity level may be less.

Tips to increase developer productivity

Whether you are a developer yourself or you primarily manage a team of developers, implementing these practices at your organization will boost overall productivity. If you manage others, remember to model good productivity in your own work. Aside from setting a positive example, growing your own productivity is a win-win.

Schedule your sleep: Plan for at least seven to nine hours of sleep every night. If necessary, set a timer and commit yourself to go to bed and waking up at consistent times. Try to stick to the schedule even on your days off.
Be a healthy remote worker: If you work remotely, be extra careful to create enough work-life separation and balance.
Follow a routine: Remote workers may struggle more with following a daily routine, but everyone benefits from building a consistent lifestyle. Routines help people feel more grounded and connected.
Stay active: Exercise is important, even if it’s just walking around the room once in a while.
Eat a balanced diet: Healthy eating helps you feel your best so you can be more productive at work.
Seek mentors: A coding mentor can help you break past challenges and see problems from a new perspective.
Mentor others: Serving as a mentor to someone else may fuel your own coding productivity and your mentee’s productivity as well.
Find your zone: Experiment with your work environment. Find when you’re the most productive and plan your big projects around that schedule.
Use music: Your favorite tunes might help you focus or they might be a distraction. Experiment with different sounds or keep your environment quiet and see how your productivity is impacted.
Try positive procrastination: Working through a hard task is sometimes easier if you rest your brain while taking a break, enjoying lunch, or changing projects temporarily.

Thanks for reading! Please leave any comments or feedback below - this will really helps me improve! 👇‍