DEV Community: MFONIDO MARK

Quality As A Shared Responsibility

MFONIDO MARK — Fri, 16 Jan 2026 15:56:39 +0000

Quality as a Shared Responsibility

How High-Performing Teams Build Predictable, Scalable, and Excellent Products

Introduction – Why Quality Is Everyone’s Business

In modern software development, quality is no longer a phase, a department, or a final checkbox before release. It is a continuous, shared responsibility that spans product management, design, engineering, site reliability, and quality assurance.

Yet, many teams still behave as if quality “belongs” to QA, or that it is something to be fixed after features are built. This mindset leads to:

Fragile systems
Unhappy users
Burned-out teams
Endless firefighting

High-performing teams understand something different:

Quality is not added at the end. Quality is designed, built, tested, and protected at every stage.

When quality is treated as a team sport, organizations build systems that are:

Predictable
Scalable
Resilient
Trustworthy
And genuinely delightful to use

This article explores:

Why quality breaks in most teams
What quality really means beyond “no bugs”
How each role contributes to quality
And how great teams build a culture where quality is everyone’s job

The Friday Night Incident

It was 9:47pm on a Friday.
Mark, a frontend engineer, was already halfway through a movie when his phone buzzed. Then buzzed again and again.

ALERT: Checkout API latency spiking
ALERT: Error rate > 12%
ALERT: Payment failures reported

Slack exploded, customer support tickets piled up, and X (formerly Twitter) started complaining.
By Monday morning, the blame game had begun:

Product: "Why didn't anyone flag this edge case?"
Design: "That flow was never meant to work that way."
Frontend: "The API response changed."
Backend: "The requirements were unclear."
QA: "We didn't test that scenario."
SRE: "We had no alert for this path."

And there it was, the classic "throw it over the wall" failure.
No one was lying. Everyone was partially right and yet... the system still failed.

This is what happens when quality has no owner.

The "Throw it over the wall" problem.

“Throw It Over the Wall” means:

Completing your own task in isolation and passing it to another team without caring about integration, quality, usability, or downstream impact.

In many organizations, work still flows like this:

Product => Design => Frontend => Backend => QA => Production

Each team does their part, then throws it over the wall

[ Product ] → [ Design ] → [ Frontend ] → [ Backend ] → [ QA ] → [ Users ]
    "Done"        "Done"        "Done"        "Done"      "Done"
      |__________________________________________________________|
                              THE WALL

Why This Model Fails

This model assumes:

Requirements are always perfect
Designs are always clear
Developers always interpret correctly
QA can catch everything
Ops can magically stabilize broken systems

In reality, this creates:

Late discovery of bugs – when they are most expensive to fix
Siloed thinking – “not my problem” mentality
Blame culture – instead of a problem-solving culture
Slow feedback loops – issues travel too far before being seen

When quality is treated as a handoff instead of a shared outcome, defects become inevitable.

What Does "Quality" Really Mean?

At its core:

Quality is not how good something looks.
Quality is how well something serves its purpose for the user—consistently, reliably, and without pain.

Or more simply:

Quality = Fitness for use

If the product does what users need, in the way they expect, without friction or failure, that’s quality.

Most teams say they want “high quality.”
Few can define what that actually means.

Quality is not just:

No bugs
No crashes
No errors

Those are minimum expectations, not quality.

Real Quality Means:

Users can complete their goals easily
The system behaves predictably
Performance is fast and consistent
Errors are clear and recoverable
The experience feels trustworthy
The product works for everyone, including users with disabilities

The Quality Equation

Quality = Value + Clarity + Predictability

Value – Does this solve a real problem?
Clarity – Is it easy to understand and use?
Predictability – Does it behave consistently? If any of these are missing, the experience breaks.

The Dimensions of Quality

Quality is multi-dimensional; It must be addressed holistically.

-Functional Quality

Does the feature work as intended?
Does it meet the business requirement?

-Usability

Can users achieve their goals without confusion?
Is the flow intuitive?

-Performance

Does the system feel fast?
Does it respond within an acceptable time?

-Stability & Reliability

Does it work consistently?
Does it fail gracefully?

-Aesthetics & UX

Is the experience cohesive?
Does it feel polished and intentional?

-Accessibility

Can users with disabilities use it?
Is it keyboard navigable, screen reader friendly, and colour-safe?

-Operational Quality

Does it scale?
Can it recover from failure?

-Validation & Verification

Is it tested?
Is it protected from regressions?

Neglecting any one of these leads to hidden cracks in the product.

A User’s Journey: Where Quality Breaks in Real Life

Let’s follow Blessing, trying to pay for a service:

Login => Select Plan => Enter Card => Confirm => Success

Simple, right?

Where Quality Breaks:

Design flaw: Button looks disabled but isn’t
Frontend bug: Loading spinner never stops on slow network
Backend issue: API returns 500 with no message
SRE gap: No alert on this endpoint
QA miss: Edge case not tested

To Blessing, it's just one thing:

"This app is broken."

She does not care:

which team wrote the code
which requirement was unclear
which alert was missing

The user experiences the system as one thing.
Your organization structure is invisible to them.

Why Quality Fails in Most Organizations

Quality usually fails due to systemic issues, not individual incompetence.

-Ambiguity

Unclear requirements.
Vague acceptance criteria.
Assumptions everywhere.

-Poor Communication

Design not aligned with product.
Engineering not aligned with design.
QA looped in too late.

-Rushed Timelines

Shipping becomes more important than correctness.
Corners get cut. Debt accumulates.

-Over-Reliance on QA

“QA will catch it” is not a strategy.
QA is a safety net, not a crutch.

-Lack of Observability

No logs. No metrics. No alerts.
Problems exist but are invisible.

-Lack of Ownership

“No one told me.”
“That’s not my responsibility.”

This is the silent killer of quality.

Quality as a Shared Responsibility (The Team Sport Model)

The mindset shift:

Old: “That’s QA’s job.”
New: “That’s our job.”

          [ Product ]
               ↑
[ Design ] ← [ QUALITY ] → [ Engineering ]
               ↓
             [ SRE ]
               ↓
              [ QA ]

Quality is shaped by:

Product Managers – clarity and priorities
Designers – usability and flow
Frontend Engineers – interaction quality
Backend Engineers – logic and data integrity
SREs – reliability and resilience
QA Engineers – validation and coverage

No single role owns quality. Everyone does.

The Role of Product Management in Quality

Product Managers are the architects of clarity.

Their Impact on Quality:

Define what success looks like
Remove ambiguity from requirements
Align teams around the same outcome
Balance speed with sustainability

Bad Requirement:

"User should be able to pay easily."

Good Requirement:

User completes payment in ≤ 3 steps
Error shown for invalid card
Retry allowed without losing data
Success state within 2s of API response

Clarity reduces defects before they exist.

The Role of Design in Quality

Design is not decoration.
Design is decision-making.

Design quality means:

Clear hierarchy
Obvious actions
Reduced cognitive load
Accessible experiences

Example
Before
[Pay]

After:
[Pay $5,000 Securely] 🔒

Same action, more confidence. Less friction.

Design prevents:

Hesitation
Confusion
User error

The Role of Frontend Engineering in Quality

Frontend engineers are the guardians of user experience.

They shape:

Performance
Accessibility
Error handling
Feedback states
Visual consistency

<script lang="ts" setup>
interface CheckoutResponse {
  success: boolean
  transactionId: string
  message?: string
}

const checkout = async () => {
  state.value = 'loading'
  errorMessage.value = null

  try {
    const { data, error } = await useFetch<CheckoutResponse>('/api/checkout', {
      method: 'POST'
    })

    if (error.value) {
      throw new Error(error.value.message || 'Network error')
    }

    if (!data.value || !data.value.success) {
      throw new Error(data.value?.message || 'Payment could not be completed')
    }

    state.value = 'success'
  } catch (err: any) {
    state.value = 'error'
    errorMessage.value = err.message || 'Something went wrong. Please try again.'
  }
}
</script>

<template>
  <div>
    <div v-if="state === 'loading'" aria-live="polite">
      We’re securely processing your payment. Please don’t close this window.
    </div>

    <div v-else-if="state === 'error'" class="error">
      <p>{{ errorMessage }}</p>
      <button @click="checkout">Try again</button>
    </div>

    <div v-else-if="state === 'success'" class="success">
      <h3>Payment successful 🎉</h3>
      <p>Your transaction has been completed.</p>
    </div>
  </div>
</template>

No blank screens, No confusion, No silent failures.
That is quality.

The Role of Backend Engineering in Quality

Backend engineers are the protectors of truth.

They ensure:

Correct business logic
Predictable APIs
Proper error handling
Data integrity
Security

{
  "success": false,
  "errorCode": "INSUFFICIENT_FUNDS",
  "message": "Your balance is too low to complete this transaction"
}

Clear contracts prevent guesswork and guesswork is where bugs are born.

The Role of Site Reliability Engineering (SRE) in Quality

SREs make quality operationally real.

They handle:

Monitoring
Alerting
Uptime
Recovery
Resilience

Flow:

Request → Metrics → Alert → Engineer → Fix → Post-mortem

Example:

99.9% of checkout requests < 500ms

Without SRE, quality is hope.
With SRE, quality is measurable.

The Role of QA Engineering in Quality

QA are the system thinkers.

They:

Explore edge cases
Break assumptions
Validate flows
Prevent regressions

Example:

Scenario: Network drops during payment
Then: User sees retry
And: No double charge occurs

QA doesn’t just test.
QA protects the user.

Shift Left: Catching Problems Before They Exist

Instead of:

Code → QA → Fix → Repeat

High-performing teams do:

Design Review → Requirement Review → Dev + Tests → QA → Release

Problems are cheaper:

to discuss than to code
to change than to refactor
to prevent than to fix

Automation: Scaling Quality with Confidence

Automation is your 24/7 quality guard.

Unit tests catch logic errors.
E2E tests catch flow breaks.
CI pipelines catch regressions.

Machines don’t forget and machines don’t get tired.

Observability and Measurement: Making Quality Visible

You cannot improve what you cannot see.

Track:

Defect escape rate
MTTR / MTTD
Uptime
Change failure rate
NPS
Feature adoption

These connect engineering quality to business impact.

Building a Strong Quality Culture

Tools don’t create quality.
Culture does.

High-quality cultures are:

Blameless
Curious
Collaborative
Learning-driven
Ownership-focused

Quality is discussed, Quality is measured, Quality is respected.

A Different Friday Night

Three months later.
It’s Friday again. 9:47 PM.

No alerts. No pings. No panic.

Users are paying.
Systems are stable.
Teams are calm.

Not because there are no bugs, but because quality is now built in, not bolted on.

Summary

This article explores quality as a shared responsibility across the entire product lifecycle, challenging the outdated idea that quality belongs only to QA or happens at the end of development. Through real-world storytelling and practical examples, it shows how quality is shaped at every stage, from product definition and design decisions to frontend implementation, backend reliability, site reliability engineering, and quality assurance.

We examined the dangers of the “throw it over the wall” approach, where teams work in silos and defects are discovered too late. We redefined quality as more than the absence of bugs, framing it instead as the combination of value, clarity, and predictability. The article also broke down the multiple dimensions of quality — functional, usability, performance, reliability, accessibility, operational stability, and validation, emphasizing that neglecting any of these weakens the entire user experience.

Each role in the product team was highlighted as a critical contributor to quality:

Product Managers drive clarity and alignment through well-defined requirements.
Designers reduce cognitive load and shape intuitive user journeys.
Frontend Engineers craft responsive, accessible, and resilient interfaces.
Backend Engineers ensure data integrity, correct business logic, and predictable APIs.
SREs make quality operational through monitoring, alerting, and resilience.
QA Engineers safeguard stability by validating behavior and preventing regressions.

The article also emphasized Shift Left practices, automation, observability, and meaningful metrics as key enablers of sustainable quality. Most importantly, it made the case that tools and processes alone are not enough, quality must be embedded in culture through collaboration, ownership, blameless learning, and continuous improvement.

Conclusion: Quality Is a Culture, Not a Phase

Quality is not something you add at the end of a sprint.
It is not something you delegate to QA.
It is not something you fix after users complain.

Quality is a culture.

It is shaped by every requirement written, every design decision made, every line of code shipped, every alert configured, and every test created. It lives in how teams communicate, how they handle ambiguity, how they respond to failure, and how they take ownership of outcomes.

High-performing teams do not ask, “Who broke it?”
They ask, “How did the system allow this to happen?”

They do not throw work over walls.
They build together.

They do not rely on heroics.
They rely on clarity, collaboration, and consistency.

When quality becomes a shared responsibility:

Products become predictable
Systems become resilient
Teams become confident
Users become loyal

And in a world where users have endless alternatives, quality is not just a technical goal; it is a competitive advantage.

Build it in.
Protect it.
Own it together.

A Comprehensive Guide to Getting Started as a Technical Writer

MFONIDO MARK — Thu, 29 Feb 2024 22:03:51 +0000

Introduction:

Technical writing is a specialized form of writing that involves conveying complex information in a clear and concise manner. It plays a crucial role in various industries, including technology, healthcare, engineering, and manufacturing, among others. If you have a knack for explaining intricate concepts in simple terms and have a passion for writing, a career as a technical writer might be an excellent fit for you. This comprehensive guide will walk you through the steps to kickstart your journey as a technical writer.

Understand the Role of a Technical Writer

Before diving into the field, it's essential to have a clear understanding of what technical writers do. They are responsible for creating documentation such as user manuals, guides, tutorials, and online help systems accompanying products or services. Technical writers collaborate closely with subject-matter experts (SMEs) to gather information and translate it into easily understandable content for the target audience.

Develop Relevant Skills

Technical writing requires writing skills, technical proficiency, and the ability to communicate complex ideas effectively. Here are some essential skills to develop:

Writing Skills: Mastering grammar, syntax, and style is fundamental to conveying information. Practice writing concise and precise sentences, and learn to tailor your writing to different audiences.
Technical Proficiency: While you don't need to be an expert in every subject you write about, having a basic understanding of technical concepts and terminology is essential. Familiarize yourself with industry-standard tools and software used for documentation, such as Microsoft Word, Adobe FrameMaker, or MadCap Flare.
Research Skills: Technical writers often need to research unfamiliar topics to gather accurate information. Learn how to find reliable sources, evaluate information for relevance and credibility, and synthesize complex concepts into coherent documentation.
Communication Skills: Effective communication is critical to collaborating with SMEs and understanding end-users' needs. Practice active listening, asking clarifying questions, and presenting information that resonates with your audience.

Gain Experience

A portfolio is crucial for showcasing your skills and expertise as a technical writer. Start by seeking out opportunities to gain hands-on experience, such as:

Volunteer Work: Offer to write documentation for open-source projects or non-profit organizations. This not only helps you build your portfolio but also allows you to contribute to meaningful causes.
Internships or Entry-Level Positions: Look for internships or entry-level positions in companies that require technical documentation. Even if the role is unpaid or low-paying, the experience you gain will be invaluable for your career growth.
Freelance Projects: Platforms like Upwork, Freelancer, or Fiverr offer opportunities to work on freelance technical writing projects. Build a network of clients and gradually expand your portfolio.

Tools for Technical writers

Technical writers use various tools to efficiently create, edit, manage, and publish documentation. These tools help streamline the writing process, collaborate with team members, and ensure the quality and consistency of the final documentation. Here are some essential tools commonly used in technical writing:

Word Processors:

Microsoft Word: Microsoft Word is a widely used word processing software that offers features such as spell check, grammar check, and formatting options. It's commonly used for drafting and editing documentation.
Google Docs: A cloud-based alternative to Microsoft Word, allowing real-time collaboration and sharing among multiple users.

Authoring Tools:

Adobe FrameMaker: A professional authoring and publishing tool designed specifically for technical documentation. It supports structured authoring, single-sourcing, and multichannel publishing.
MadCap Flare: A comprehensive authoring and content management tool that enables single-source publishing in various formats, such as HTML5, PDF, and mobile.
DITA (Darwin Information Typing Architecture) Tools: DITA-based authoring tools like Oxygen XML Editor or Adobe XML Author are used to create structured content following the DITA standard.

Version Control Systems:

Git: A distributed version control system widely used for tracking changes in source code and documentation. It allows multiple contributors to collaborate on documentation projects while managing revisions and updates.
Subversion (SVN): A centralized version control system that tracks changes to files and directories over time. It's commonly used for managing documentation projects with a linear history of changes.

Content Management Systems (CMS):

WordPress: A popular open-source CMS primarily used for creating and managing blogs and websites. It offers plugins and themes tailored for technical documentation.
Drupal: Another open-source CMS that provides extensive customization options and modules for creating and organizing technical content.

Graphics and Illustration Tools:

Adobe Illustrator: A vector graphics editor for creating diagrams, illustrations, and visual aids for technical documentation.
Snagit: A screen capture and editing tool that allows users to capture screenshots, annotate images, and create instructional videos.
Microsoft Visio: A diagramming tool that enables users to create flowcharts, diagrams, and technical drawings for visualizing complex concepts.

Project Management and Collaboration Tools:

Jira: A project management tool commonly used for agile software development and suitable for tracking tasks and milestones in technical writing projects.
Trello: A visual collaboration tool that uses boards, lists, and cards to organize and prioritize tasks in documentation projects.
Slack: A team communication platform that facilitates real-time messaging, file sharing, and collaboration among team members working on documentation projects.

Localization and Translation Tools:

SDL Trados Studio: A translation management software for translating and localizing documentation into multiple languages while maintaining consistency and quality.
memoQ: Another translation management tool that supports collaborative translation workflows, terminology management, and quality assurance checks.

Continuous Learning and Improvement

Technology constantly evolves, and technical writers must stay updated with the latest trends and developments. Consider pursuing certifications or attending workshops and seminars to enhance your skills. Join professional associations like the Society for Technical Communication (STC) to connect with fellow technical writers and access resources for professional development.

Build Your Brand

Creating a solid personal brand can help you stand out in the competitive field of technical writing. Maintain an updated LinkedIn profile showcasing your skills, experience, and portfolio. Start a blog where you share insights, tips, and industry-related content to establish yourself as a thought leader. Engage with the technical writing community on social media platforms like Twitter or LinkedIn to network and stay informed about job opportunities.

Conclusion:

Becoming a successful technical writer requires skills, experience, and continuous learning. By understanding the role, developing relevant skills, gaining practical experience, and actively working on your professional development, you can embark on a fulfilling career in technical writing. Stay curious, keep honing your craft, and embrace the ever-evolving nature of technology to thrive in this dynamic field.

Error Messages: The Art of Effective Communication in Software Development

MFONIDO MARK — Wed, 24 Jan 2024 09:14:29 +0000

Introduction

Error messages are an integral part of any software application. They serve as a communication channel between the software and its users, providing crucial information about what went wrong when an error occurs. Writing proper error messages is an art that every software developer should master. In this article, we will explore the importance of clear and concise error messages, best practices for crafting them, and their impact on the user experience and troubleshooting.

Why Proper Error Messages Matter

Effective error messages are essential for several reasons:

User Experience: Clear and understandable error messages enhance the user experience by guiding users on how to resolve issues efficiently.
Troubleshooting : Well-crafted error messages assist developers in identifying the root cause of problems, speeding up the debugging process.
User Trust : Transparent error messages build trust with users, showing them that the software is reliable and the developers care about their experience.

Best Practices for Writing Error Messages

Be Clear and Concise : Use plain language and avoid technical jargon. Clearly state what happened and why it occurred.

// Bad Example
throw new Error("Something went wrong!");

// Good Example
throw new Error("Failed to process the request. Please check your input and try again.");

Be Specific : Provide precise details about the error, including error codes if applicable. Vague messages like "An error occurred" are unhelpful.

// Bad Example
console.error("Error occurred!");

// Good Example
console.error("Error occurred while fetching user data.");

Offer Guidance / Solutions : Suggest possible solutions or actions the user can take to resolve the issue. This could include checking internet connection, verifying input, or contacting support.

// Bad Example
throw new Error("Access Denied.");

// Good Example
throw new Error("Access Denied. Please log in to continue.");
// Good Example
throw new Error("Access Denied. You dont have permission to access this page, please contact admin.");

Avoid Blame : Do not blame the user for the error. Instead, focus on helping them understand the problem and how to fix it.
Use Formatting : Format error messages consistently. Use proper grammar, punctuation, and capitalization to enhance readability.
Include Context : Provide context about what the user was trying to accomplish when the error occurred. This helps developers understand the scenario leading to the error.

Types of Error Messages

Validation Errors : Occur when user input doesn’t meet required criteria (e.g., invalid email format).
Authorization Errors : Arise when a user lacks permission to perform a specific action.
Connection Errors : Happen when the software cannot establish a connection to a server or database.
Critical Errors : Severe issues that prevent the software from functioning properly, requiring immediate attention.

Real-World Examples

Example 1: Validation Error

//Bad Error Message: 
"Invalid input. Please try again."

//Improved Error Message: 
"The email address you entered is not valid. Please use a valid email address (e.g., example@example.com)."

Example 2: Authorization Error

//Bad Error Message:
"Access Denied."

//Improved Error Message: 
"Access Denied. You do not have permission to perform this action. Please contact your administrator for assistance."

Conclusion

Writing proper error messages is a skill that can significantly enhance the user experience and streamline the development process. By following best practices, developers can create error messages that are clear, informative, and user-friendly. Remember, error messages are not just about reporting problems; they are an opportunity to engage with users, assist them in problem-solving, and foster trust in your software. Mastering the art of crafting effective error messages is a fundamental aspect of being a successful software developer.

Debouncing in JavaScript

MFONIDO MARK — Sat, 23 Sep 2023 21:27:30 +0000

Introduction

Debouncing is a common technique in JavaScript used to control how frequently a function is called, especially in response to events like scrolling or typing. It helps improve performance by reducing the number of function calls, which can be critical in scenarios where you want to avoid excessive processing or network(API) requests. In this article, we'll explore the concept of debouncing, and why it's important.

Understanding Debouncing

Imagine a scenario where you have a search input field on a web app, and you want to fetch search results from a server as the user types. Without debouncing, a request would be sent with every keystroke, potentially overwhelming the server and causing unnecessary network traffic. Debouncing helps solve this problem by delaying the execution of a function until a specified time has passed since the last triggering event.

The Debouncing Process

An event, such as a keypress or mouse movement, triggers a function.
Instead of executing the function immediately, a timer is set for a specific duration (the debounce delay).
If another event occurs before the timer expires, the previous timer is canceled, and a new one is set.
When the timer finally expires without any new events, the function is executed.

Use Cases for Debouncing

Debouncing is valuable in various scenarios:

1 . Search Suggestions: As mentioned earlier, it prevents excessive requests to a server when users type in a search bar.

2 . Infinite Scrolling: When users scroll through a long list, debouncing can be used to fetch more content only when they pause scrolling.

Implementing Debouncing in JavaScript

To implement debouncing in JavaScript, you can use either a basic function or a higher-order function. Below, we'll provide examples for both approaches.

function debounce(func, delay) {
  let timerId;

  return function (...args) {
    clearTimeout(timerId);
    timerId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Usage:
const searchInput = document.getElementById('search-input');
const debounceSearch = debounce(search, 300);

searchInput.addEventListener('keyup', debounceSearch);

function search() {
  // Perform the search operation here
  console.log('Searching for:', searchInput.value);
}

debounce is a function that takes a function func and a delay delay.
It returns a new function that clears the previous timer and sets a new one every time it's called.
The search function is our actual operation, and it is wrapped by the debounce function. It will only execute after the user stops typing for 300 milliseconds.

Higher-Order Function Example

A higher-order function version might look like this:

function debounce(func, delay) {
  let timerId;

  return function (...args) {
    clearTimeout(timerId);
    timerId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Usage:
const searchInput = document.getElementById('search-input');
const debounceSearch = debounce(performSearch, 300);

searchInput.addEventListener('keyup', debounceSearch);

function performSearch() {
  // Perform the search operation here
  console.log('Searching for:', searchInput.value);
}

debounce is still a function that takes a function func and a delay delay.
It returns a new function, which is assigned to debounceSearch. This function wraps the performSearch function.

The higher-order function approach allows you to debounce various functions without duplicating the debouncing logic.

Conclusion

Debouncing is a fundamental concept in JavaScript for improving performance in scenarios where you need to limit function execution. Whether you're building a search bar, implementing infinite scrolling, or handling other real-time user interactions, understanding and using debouncing can significantly enhance the user experience and optimize your application.

Writing Clean Code: Best Practices and Principles

MFONIDO MARK — Sat, 16 Sep 2023 21:12:29 +0000

Introduction

Writing clean code is a fundamental skill for every software developer. Clean code not only makes your codebase more maintainable and easier to understand but also fosters collaboration among team members. In this comprehensive article, we will explore what clean code is, why it's important, and provide you with a set of best practices and principles to help you write clean and maintainable code.

What is Clean Code?

Clean code is code that is easy to read, easy to understand, and easy to modify. It is code that is devoid of unnecessary complexity, redundancy, and confusion. Clean code follows a set of conventions and best practices that make it more consistent, making it easier for multiple developers to work on the same project seamlessly.

Why is Clean Code Important?

Readability: Clean code is easy to read, which means that anyone - including your future self - can understand it quickly. This reduces the time required to grasp the code's functionality, leading to faster development and debugging.
Maintainability: Code is read more often than it is written. When you write clean code, it becomes easier to maintain and extend the application over time. This is crucial in the software development lifecycle, where projects often evolve and grow.
Collaboration: Clean code encourages collaboration. When your code is clean and well-organized, other team members can work on it effectively. This makes it easier to divide tasks and work on different parts of the codebase simultaneously.
Bug Reduction: Clean code reduces the likelihood of introducing bugs. Code that is difficult to understand is more prone to errors during modifications or enhancements.
Efficiency: Clean code is efficient code. It typically runs faster and uses fewer resources because it avoids unnecessary operations and complexity.

Now that we understand why clean code is important, let's delve into some best practices and principles to help you write clean code.

Best Practices and Principles for Writing Clean Code

1 . Meaningful Variable and Function Names

Use descriptive names for variables, functions, classes, and other identifiers. A well-chosen name can convey the purpose of the entity, making the code more understandable. Avoid single-letter variable names or cryptic abbreviations.

# Bad variable name
x = 5

# Good variable name
total_score = 5

2 . Keep Functions and Methods Short

Functions and methods should be concise and focused on a single task. The Single Responsibility Principle (SRP) states that a function should do one thing and do it well. Shorter functions are easier to understand, test, and maintain. If a function becomes too long or complex, consider breaking it down into smaller, more manageable functions.

// Long and complex function
function processUserData(user) {
    // Many lines of code...
}

// Refactored into smaller functions
function validateUserInput(userInput) {
    // Validation logic...
}

function saveUserToDatabase(user) {
    // Database operation...
}

3 . Comments and Documentation

Use comments sparingly, and when you do, make them meaningful. Code should be self-explanatory whenever possible. Documentation, such as inline comments and README files, helps other developers understand your code's purpose and usage. Document complex algorithms, non-trivial decisions, and public APIs.

# Bad comment
x = x + 1  # Increment x

# Good comment
# Calculate the total score by incrementing x
total_score = x + 1

4 . Consistent Formatting and Indentation

Adhere to a consistent coding style and indentation. This makes the codebase look clean and organized. Most programming languages have community-accepted coding standards (e.g., PEP 8 for Python, eslint for JavaScript) that you should follow. Consistency also applies to naming conventions, spacing, and code structure.

// Inconsistent formatting
if(condition){
    doSomething();
  } else {
      doSomethingElse();
}

// Consistent formatting
if (condition) {
    doSomething();
} else {
    doSomethingElse();
}

5 . DRY (Don't Repeat Yourself) Principle

Avoid duplicating code. Repeated code is harder to maintain and increases the risk of inconsistencies. Extract common functionality into functions, methods, or classes to promote code reusability. When you need to make a change, you'll only need to do it in one place.

Suppose you're working on a JavaScript application that calculates the total price of items in a shopping cart. Initially, you have two separate functions for calculating the price of each item type: one for calculating the price of a book and another for calculating the price of a laptop. Here's the initial code:

function calculateBookPrice(quantity, price) {
    return quantity * price;
}

function calculateLaptopPrice(quantity, price) {
    return quantity * price;
}

While these functions work, they violate the DRY principle because the logic for calculating the total price is repeated for different item types. If you have more item types to calculate, you'll end up duplicating this logic. To follow the DRY principle and improve code maintainability, you can refactor the code as follows:

function calculateItemPrice(quantity, price) {
    return quantity * price;
}

const bookQuantity = 3;
const bookPrice = 25;

const laptopQuantity = 2;
const laptopPrice = 800;

const bookTotalPrice = calculateItemPrice(bookQuantity, bookPrice);
const laptopTotalPrice = calculateItemPrice(laptopQuantity, laptopPrice);

In this refactored code, we have a single calculateItemPrice function that calculates the total price for any item type based on the quantity and price provided as arguments. This adheres to the DRY principle because the calculation logic is no longer duplicated.

Now, you can easily calculate the total price for books, laptops, or any other item type by calling calculateItemPrice with the appropriate quantity and price values. This approach promotes code reusability, readability, and maintainability while reducing the risk of errors caused by duplicated code.

6 . Use Meaningful Whitespace

Properly format your code with spaces and line breaks. This enhances readability. Use whitespace to separate logical sections of your code. Well-formatted code is easier to scan, reducing the cognitive load on readers.

// Poor use of whitespace
const sum=function(a,b){return a+b;}

// Improved use of whitespace
const sum = function (a, b) {
    return a + b;
}

7 . Error Handling

Handle errors gracefully. Use appropriate try-catch blocks or error-handling mechanisms in your code. This prevents unexpected crashes and provides valuable information for debugging. Don't suppress errors or simply log them without a proper response.

// Inadequate error handling
try {
    result = divide(x, y);
} catch (error) {
    console.error("An error occurred");
}

// Proper error handling
try {
    result = divide(x, y);
} catch (error) {
    if (error instanceof ZeroDivisionError) {
        console.error("Division by zero error:", error.message);
    } else if (error instanceof ValueError) {
        console.error("Invalid input:", error.message);
    } else {
        console.error("An unexpected error occurred:", error.message);
    }
}

8 . Testing

Write unit tests to verify your code's correctness. Test-driven development (TDD) can help you write cleaner code by forcing you to consider edge cases and expected behavior upfront. Well-tested code is more reliable and easier to refactor.

// Example using JavaScript and the Jest testing framework
test('addition works correctly', () => {
    expect(add(2, 3)).toBe(5);
    expect(add(-1, 1)).toBe(0);
    expect(add(0, 0)).toBe(0);
});

9 . Refactoring

Refactor your code regularly. As requirements change and your understanding of the problem domain deepens, adjust your code accordingly. Refactoring helps maintain clean code as the project evolves. Don't be afraid to revisit and improve existing code when necessary.

Suppose you have a function that calculates the total price of items in a shopping cart with a fixed discount percentage:

function calculateTotalPrice(cartItems) {
    let totalPrice = 0;
    for (const item of cartItems) {
        totalPrice += item.price;
    }
    return totalPrice - (totalPrice * 0.1); // Apply a 10% discount
}

Initially, this function calculates the total price and applies a fixed discount of 10%. However, as the project evolves, you realize that you need to support variable discounts. To refactor the code to make it more flexible, you can introduce a discount parameter:

function calculateTotalPrice(cartItems, discountPercentage) {
    if (discountPercentage < 0 || discountPercentage > 100) {
        throw new Error("Discount percentage must be between 0 and 100.");
    }

    let totalPrice = 0;
    for (const item of cartItems) {
        totalPrice += item.price;
    }

    const discountAmount = (totalPrice * discountPercentage) / 100;
    return totalPrice - discountAmount;
}

In this refactored code:

We have added a discountPercentage parameter to the calculateTotalPrice function, allowing you to specify the discount percentage when calling the function.
We perform validation on the discountPercentage parameter to ensure it falls within a valid range (0 to 100%). If it's not within the range, we throw an error.
The discount calculation is now based on the provided discountPercentage, making the function more flexible and adaptable to changing requirements.

By refactoring the code in this way, you have improved its flexibility and maintainability. You can easily adapt the function to handle different discount scenarios without having to rewrite the entire logic. This demonstrates the importance of regular code refactoring as your project evolves and requirements change.

10 . Version Control

Use version control systems like Git to track changes to your code. This allows you to collaborate effectively with team members, revert to previous versions if necessary, and maintain a clean history of your project's development. Git provides tools for code review, branching, and merging, facilitating collaboration and code cleanliness.

Conclusion

Writing clean code is not just a set of rules but a mindset and a discipline. It's about creating software that is easy to read, maintain, and extend. By following these best practices and principles, you can become a more proficient developer who produces high-quality code.Investing time in meticulously examining fellow engineers' codebases, particularly in open-source projects, can be an enlightening experience. Through this exploration, you gain invaluable insights into diverse coding styles and strategies. This exposure enables you to distill the essence of writing pristine, sustainable codebases.. Remember that clean code is a continuous journey, and with practice, it becomes second nature, leading to more efficient and enjoyable software development.

Community!,The What? The Why? And The When?

MFONIDO MARK — Thu, 03 Aug 2023 21:06:55 +0000

The power of community can never be overemphasised, because the benefits it brings to everyone irrespective of your profession is very much.

we are going to be talking about the what, the why and the when of a community.

THE WHAT?

A community is a social construct that encompasses a group of individuals who share common interests, values, goals, or geographical proximity, and interact with one another on a regular basis. It is a network of relationships formed by people who come together to support, collaborate, and engage in various activities.

At its core, a community represents a sense of belonging and interconnectedness among its members. It provides a platform for individuals to connect, communicate, and establish meaningful relationships, whether in person or through virtual interactions. Communities can range in size and scope, from small local neighborhoods to large-scale online networks spanning across the globe.

Key Characteristics of a Community:

Shared Identity: Communities are united by a shared identity or common purpose. This could be based on factors such as shared interests, cultural background, profession, or geographic location.
Interactions and Relationships: Communities thrive on social interactions and the relationships that develop within them. Members engage with one another through communication, cooperation, and mutual support, fostering a sense of belonging and camaraderie.
Collective Goals: Communities often have collective goals or objectives that they strive to achieve. These goals can vary widely, ranging from social, environmental, or political causes to personal development, professional advancement, or recreational pursuits.
Norms and Values: Communities establish a set of norms, values, and shared beliefs that guide their interactions and behavior. These norms can shape the community's culture, ethical standards, and expectations of its members.
Sense of Place: In some cases, communities are tied to a specific geographic location or physical space, such as a neighborhood, town, or village. This shared physical environment contributes to a sense of place and local identity.
Support and Collaboration: Communities provide a support system for their members, offering assistance, resources, and a platform for collaboration. Members often come together to solve problems, address common issues, or pursue collective endeavors.
Communication Channels: Effective communication is vital to the functioning of a community. It enables members to share information, exchange ideas, coordinate activities, and strengthen social bonds.
Diversity and Inclusion: Communities can encompass diverse individuals with varied backgrounds, perspectives, and experiences. Embracing diversity and promoting inclusivity fosters a richer and more vibrant community environment.
Evolution and Change: Communities are not static entities but evolve and adapt over time. They respond to external influences, societal changes, and individual needs, allowing for growth, innovation, and renewal.

THE WHY?

There are numerous reasons why individuals choose to join communities. Joining a community offers a range of benefits and opportunities that can enhance various aspects of one's life.

Here are some comprehensive reasons why people choose to join communities:

Sense of Belonging: Joining a community provides a sense of belonging and connection with others who share similar interests, values, or experiences. It creates a social support system that can combat feelings of isolation or loneliness.
Networking and Socializing: Communities offer opportunities to expand one's network and meet new people. Building relationships within a community can lead to new friendships, professional connections, and collaborations.
Personal Growth and Development: Communities often provide platforms for personal growth and development. They may offer resources, workshops, or mentorship programs that enable individuals to acquire new skills, knowledge, and perspectives.
Sharing and Learning: Communities provide a space for sharing ideas, knowledge, and experiences. They offer opportunities to learn from others, gain insights, and contribute to the collective wisdom of the group.
Support and Encouragement: Communities can be a source of support during challenging times. They offer a network of individuals who can provide advice, guidance, and emotional support. Sharing experiences and receiving encouragement from like-minded individuals can boost motivation and resilience.
Collaboration and Collective Action: Communities often come together to work towards shared goals or causes. Joining a community allows individuals to participate in collective action, make a positive impact, and contribute to social change.
Access to Resources and Opportunities: Communities can provide access to resources, information, and opportunities that may not be readily available otherwise. This can include job leads, educational resources, funding, or specialized knowledge.
Personal Identity and Expression: Communities offer a platform for individuals to express their identity and engage with others who share similar values or cultural backgrounds. They provide a space where individuals can be authentic and feel accepted.
Fun and Recreation: Communities often organize social events, recreational activities, or hobbies that can bring joy and entertainment. Joining a community allows individuals to engage in shared interests and find outlets for relaxation and enjoyment.
Civic Engagement and Empowerment: Communities can empower individuals by giving them a voice and a platform to advocate for their rights or address issues of importance. By joining a community, individuals can actively participate in shaping their environment and influencing change.

THE WHEN

Deciding when to join a community depends on various factors and individual circumstances.

Here are some comprehensive considerations that can help determine the right time to join a community:

Personal Readiness: Consider your own readiness and willingness to engage in a community. Are you open to meeting new people, participating in group activities, and contributing to the community? Assess your availability, energy levels, and commitment to actively engage with others.
Interest and Alignment: Join a community when you have a genuine interest in the community's purpose, values, or activities. Look for communities that align with your passions, hobbies, professional goals, or personal values. When there is a strong alignment, it becomes easier to connect with like-minded individuals and actively contribute.
Need for Support or Connection: If you feel a need for social support, a sense of belonging, or connection with others who share similar experiences, joining a community can be beneficial. This is especially true during challenging times or life transitions when support and understanding from others can make a significant difference.
Timing of Life Events: Consider the timing of major life events or changes. Joining a community can provide a supportive network during significant life transitions such as moving to a new city, starting a new job, or entering a new phase of life. It can help you establish connections and navigate the challenges associated with these transitions.
Need for Support or Connection: If you feel a need for social support, a sense of belonging, or connection with others who share similar experiences, joining a community can be beneficial. This is especially true during challenging times or life transitions when support and understanding from others can make a significant difference.
Timing of Life Events: Consider the timing of major life events or changes. Joining a community can provide a supportive network during significant life transitions such as moving to a new city, starting a new job, or entering a new phase of life. It can help you establish connections and navigate the challenges associated with these transitions.
Availability of Resources and Opportunities: Assess whether the community offers valuable resources, opportunities, or experiences that align with your personal or professional growth goals. If the community provides access to resources, expertise, or opportunities that can enhance your development, it might be a good time to join.
Readiness for Collaboration and Collective Action: If you are motivated to collaborate with others, contribute to shared goals, or engage in collective action, joining a community can provide a platform for such endeavors. Evaluate your willingness and capacity to participate actively in the community's activities.
Geographic Proximity: If the community is based on geographic proximity, such as a local neighborhood or town, consider joining when you are living or planning to move to that area. Proximity allows for more frequent and convenient interactions with community members.
Evaluation of Personal Priorities: Assess your current priorities and commitments. Determine whether joining a community aligns with your existing responsibilities, time constraints, and other obligations. It is important to find a balance between your involvement in the community and other aspects of your life.
Openness to New Experiences: Join a community when you are open to new experiences, perspectives, and learning opportunities. Communities often provide avenues for personal growth, and being receptive to these experiences can enrich your life and broaden your horizons.
Intuition and Readiness for Change: Finally, listen to your intuition and assess your overall readiness for community involvement. Reflect on your desire for connection, growth, and making a positive impact. Trust your instincts and join a community when it feels right for you.

SUMMARY AND CONCLUSION

Communities exist in various forms, such as local communities, online communities, professional associations, cultural or religious groups, academic institutions, and many others. They play a crucial role in fostering social connections, providing support systems, promoting collective action, and shaping individual and collective identities.

Ultimately, joining a community is a personal choice based on individual needs, interests, and goals. It offers opportunities for personal, social, and professional enrichment, while also contributing to the collective well-being and progress of the community as a whole.

Remember that joining a community is a personal decision, and the timing will vary for each individual. It is important to find the right balance and consider your own needs, interests, and capacity to actively participate and contribute to the community.

Version Control With GIT (1)

MFONIDO MARK — Thu, 04 May 2023 10:40:28 +0000

A very important question.

what is version control system?
Version Control System (VCS)is a software that helps software developers to work together and maintain a complete history of their work, it is also a system that records changes to a file or set of files over time so that you can recall specific versions later.

Why Should You care?
If you are a developer and want to keep every version of your work (which you would most certainly want to), a Version Control System (VCS) is a very wise thing to use. It allows you to revert selected files back to a previous state, revert the entire project back to a previous state, compare changes over time, see who last modified something that might be causing a problem, who introduced an issue and when, and more. Using a VCS also generally means that if you screw things up or lose files, you can easily recover. In addition, you get all this for very little overhead.

Types of VCS
*Local Version Control Systems
*Centralized Version Control Systems
*Distributed Version Control Systems

Local Version Control Systems

Many people’s version-control method of choice is to copy files into another directory (perhaps a time-stamped directory, if they’re clever). This approach is very common because it is so simple, but it is also incredibly error prone. It is easy to forget which directory you’re in and accidentally write to the wrong file or copy over files you don’t mean to.To deal with this issue, programmers long ago developed local VCSs that had a simple database that kept all the changes to files under revision control.One of the most popular VCS tools was a system called RCS, which is still distributed with many computers today. RCS works by keeping patch sets (that is, the differences between files) in a special format on disk; it can then re-create what any file looked like at any point in time by adding up all the patches.

The next major issue that people encounter is that they need to collaborate with developers on other systems. To deal with this problem, Centralized Version Control Systems (CVCSs) were developed. These systems (such as CVS, Subversion, and Perforce) have a single server that contains all the versioned files, and a number of clients that check out files from that central place. For many years, this has been the standard for version control.However, this setup also has some serious downsides. The most obvious is the single point of failure that the centralized server represents. If that server goes down for an hour, then during that hour nobody can collaborate at all or save versioned changes to anything they’re working on. If the hard disk the central database is on becomes corrupted, and proper backups haven’t been kept, you lose absolutely everything — the entire history of the project except whatever single snapshots people happen to have on their local machines. Local VCS systems suffer from this same problem — whenever you have the entire history of the project in a single place, you risk losing everything.

GETTING STARTED WITH WEB DEVELOPMENT

MFONIDO MARK — Tue, 11 Jan 2022 13:03:19 +0000

A lot of persons have asked me via DM’s, or direct on how they can get started with web development and what’s the best method to use, and where they can get resources, so by the end of this article, we shall have an understanding of the basics of web development, what skills you need to know, and where to find them.

OUTLINE

1: What is web development: How websites work, front-end vs back-end, code editor‌‌
2: Basic front-end: HTML, CSS, and JavaScript‌‌
3: Tools: Package managers, build tools, version control‌‌
4a: Additional front-end: Sass, responsive design, JavaScript frameworks‌‌
4b: Basic back-end: Server and database management, programming language

NOTE:

In this roadmap, I recommend following Steps 1, 2, and 3 in order. Then, depending on whether you want to focus on more front-end or back-end, you can do steps 4a or 4b in any order.

I think it’s a good idea for front-end web developers to know at least a bit of back-end, and vice versa. At the very least, knowing the basics of both will help you figure out if you like front-end or back-end better?

1. WHAT IS WEB DEVELOPMENT?

Before we get into talking about actual coding and programming languages, let’s first look at some general information on what web development is: how websites work, the difference between front and back-end, and using a code editor.
Web development is the work involved in developing a website for the Internet or an intranet. Web development can range from developing a simple single static page of plain text to complex web applications, electronic businesses, and social network services.

HOW DO WEBSITES WORK?

All websites, at their most basic, are just a bunch of files that are stored on a computer called a server. This server is connected to the internet. You can then load that website through a browser (like Chrome, Firefox, or Safari) on your computer or your phone. Your browser is also called the client in this situation.
So, every time that you’re on the internet, you (the client) are getting and loading data (like car or cat pics) from the server, as well as submitting data back to the server (load more car or cat pics!) This back and forth between the client and the server is the basis of the internet.

WHAT IS THE DIFFERENCE BETWEEN FRONT-END AND BACK-END?

The terms “front end,” “back end,” and “full-stack” web developer describe what part of the client/server relationship you’re working with.

“Front end” means that you’re dealing mainly with the client-side. It’s called the “front end” because it’s what you can see in the browser. Conversely, the “back end” is the part of the website that you can’t see, but it handles a lot of the logic and functionality that is necessary for everything to work. One way you can think about this is that front-end web development is like the “front of house” part of a restaurant. It’s the section where customers come to see and experience the restaurant– the interior decor, seating, and of course, eating the food.

On the other hand, back-end web development is like the “back of house” part of the restaurant. It’s where deliveries and inventory are managed, and the process to create the food all happens. There’s a lot of things behind the scenes that the customers won’t see, but they will experience (and hopefully enjoy) the end product– a delicious meal!

USING A CODE EDITOR.

When you build a website, the most essential tool that you will use is your code editor or IDE (Integrated Development Environment). This tool allows you to write the markup and code that will make up the website. There are quite a few good options out there, but currently, the most popular code editor is VS Code. VS Code is a more lightweight version of Visual Studio, Microsoft’s main IDE. It’s fast, free, easy to use, and you can customize it with themes and extensions. Other code editors are Sublime Text, Atom, and Vim.

2. BASIC FRONT-END

The front-end of a website is made up of three types of files: HTML, CSS, and JavaScript. These files are what is loaded in the browser, on the client-side. Let’s take a closer look at each one of them.

HTML

HTML, or HyperText Markup Language, is the foundation of all websites. It’s the main file type that is loaded in your browser when you look at a website. The HTML file contains all the content on the page, and it uses tags to denote different types of content. For example, you can use tags to create headline titles, paragraphs, bulleted lists, images, and so on. HTML tags by themselves do have some styles attached, but they are pretty basic, like what you would see in a Word document. The HTML is used to build the structure of any website, and the current version of HTML being used currently is HTML5.

CSS

CSS, or Cascading Style Sheets, lets you style that HTML content so it looks nice and fancy. You can add colours, custom fonts, and layout the elements of your website however you want them to look. You can even create animations and shapes with CSS!
There is a lot of depth to CSS, and sometimes people tend to gloss over it so they can move on to things like JavaScript. However, I can’t overestimate the importance of understanding how to convert a design into a website layout using CSS. If you want to specialize in the front-end, it’s essential to have really solid CSS skills. And CSS helps you build responsive websites, webpages that look great on all screen sizes and multiple devices at the same time. the current version of CSS in use now is CSS3.

JAVASCRIPT

JavaScript is a multi-paradigm programming language that was designed to run in the browser. It is a prototype-based, multi-paradigm, imperative, and functional programming style. Using JavaScript, you can make your website dynamic, meaning it will respond to different inputs from the user or other sources.
For example, you can build a “Back to Top” button that when the user clicks it, they’ll scroll back up to the top of the page. Or you can build a weather widget that will display today’s weather based on the user’s location in the world.
Especially if you want to develop your skills later on with a JavaScript framework like React, you’ll understand more if you take the time to learn regular vanilla JavaScript first. It’s a really fun language to learn, and there’s so much you can do with it!

WHERE TO LEARN HTML, CSS, AND JAVASCRIPT(JS)?

A lot of persons do ask me what the best place to learn to code, and what is the best method of learning how to code. To me I prefer videos to books, it's just a matter of preference, but in all to get better at writing codes, you have to write the codes yourself, give at least 2 hours every day for practice and you will be amazed the result you will get in 4 to 7 months.
Here are some resources that will be of help to you.

FREE CODE CAMP

One of my favourite places to recommend is freeCodeCamp. It’s an online coding Bootcamp that is non-profit and completely free! I love this option because if you’re a beginner and not completely sure if coding is for you, it’s a low-pressure, risk-free way to see if you like it. One downside to freeCodeCamp is that while they do have an incredible curriculum with a built-in coding environment, they don’t have structured videos as part of it.

TEAM TREEHOUSE

Team Treehouse is a premium online learning platform that is video-based and has multiple tracks that you can follow. They even have an online Tech Degree program which is like an online Bootcamp that you can complete in 4-5 months.
Unfortunately, Treehouse isn’t free, but they do have different monthly or yearly plans depending on your budget. They have a free 7-day trial so you can see if you like it, and I can also give you a deal where you can get $100 off of 1 year of their Basic Plan. If you’re fairly certain you want to get into web development, Team Treehouse is a great place to learn.

WES BOS

Wes Bos has free courses on learning Flexbox, CSS Grid, and JavaScript that are excellent. I just went through his CSS Grid course, and it was really thorough and also fun. Wes is a great teacher!

UDEMY

Udemy is an online learning platform with a lot of great courses as well. One in particular that you might like is The Advanced CSS and Sass course by Jonas Schmedtmann– this paid course covers CSS grid, flexbox, responsive design, and other CSS topics!

YOUTUBE

There are also a ton of free video resources on YouTube:
Traversy Media, probably the biggest web development channel out there, has an HTML Crash Course and CSS Crash Course.
DesignCourse, a channel focused on web design and front-end, has an HTML & CSS tutorial for as well.
And freeCodeCamp has their own YouTube channel, with videos like a Learn JavaScript course and other in-depth courses.

BOOKS AND ARTICLES ON WEB DEVELOPMENT

If you’re more of a reading person, I would highly recommend the following:

The incredibly popular Jon Duckett books, on HTML & CSS, and JavaScript & jQuery. They are beautifully designed, really well-written, and have lots of photos and images to help teach the material.
Eloquent JavaScript And last but not least, some websites that have great articles and other resources are:
Mozilla Developer Network
CSS Tricks
Smashing Magazine

3. TOOLS

Let’s get into some other front-end technologies now. As we mentioned, HTML, CSS, and JavaScript are the basic building blocks of front-end web development. In addition to them, there are a few other tools that you’ll want to learn.

PACKAGE MANAGERS

Package managers are online collections of software, much of it open source. Each piece of software, called a package, is available for you to install and use in your own projects.
You can think about them like plugins– instead of writing everything from scratch, you can use helpful utilities that other people have written already.
The most popular package manager is called npm, or Node Package Manager, but you can also use another manager called Yarn. Both are good options to know and use, although it’s probably best to start out with npm.
If you’re curious to learn more, you can read this article on the basics of using npm.

GULP

technically a task runner, has a suite of npm packages that you can use to compile and process your files.

WEBPACK

is a super powerful bundler that can do everything Gulp can do plus more. It’s used a ton in JavaScript environments, particularly with JavaScript Frameworks (which we’ll get to in a bit). One down side of Webpack is that it requires a lot of configuration to get up and running, which can be frustrating.

PARCEL

is a newer bundler like Webpack, but it comes pre-configured out of the box, so you can literally get it going in just a few minutes. And you won’t have to worry as much about configuring everything.

VERSION CONTROL SYSTEM

Version control (also called source control) is a system that keeps track of every code change that you make in your project files. You can even revert to a previous change if you make a mistake. It’s almost like having infinite save points for your project, and let me tell you, it can be a huge lifesaver.
The most popular version control system is an open source system called Git. Using Git, you can store all your files and their change history in collections called repositories.
You may have also heard of GitHub, which is an online hosting company owned by Microsoft where you can store all your Git repositories.
To learn Git and GitHub, GitHub.com has some online guides that explain how to get up and running. Traversy Media also has a YouTube video explaining how Git works.

4A: ADDITIONAL FRONTEND

Once you have the basics of front-end down, there are some more intermediate skills that you will want to learn. I recommend that you look at the following: Sass, responsive design, and a JavaScript framework.

SASS

Sass is an extension of CSS that makes writing styles more intuitive and modular. It’s a really powerful tool. With Sass, you can split up your styles into multiple files for better organization, create variables to store colors and fonts, and use mixins and placeholders to easily reuse styles.
Even if you just utilize some of the basic features, like nesting, you will be able to write your styles more quickly and with less headache.

RESPONSIVE DESIGN

Responsive design ensures that your styles will look good on all devices–desktops, tablets, and mobile phones. The core practices of responsive design include using flexible sizing for elements, as well as utilizing media queries to target styles for specific devices and widths.
For example, instead of setting your content to be a static 400px wide, you can use a media query and set the content to be 50% width on desktop and 100% on mobile.
Building your websites with responsive CSS is a must these days, as mobile traffic is outpacing desktop traffic in many cases.

JAVASCRIPT FRAMEWORKS

Once you have the basics of vanilla JavaScript down, you may want to learn one of the JavaScript frameworks (especially if you want to be a full-stack JavaScript developer).
These frameworks come with pre-built structures and components that allow you to build apps more quickly than if you started from scratch.
Currently, you have three main choices: React, Angular, and Vue.

REACT

React (also known as React.js or ReactJS) is a free and open-source front-end JavaScript library for building user interfaces based on UI components. It is maintained by Meta (formerly Facebook) and a community of individual developers and companies.React can be used as a base in the development of single-page or mobile applications. However, React is only concerned with state management and rendering that state to the DOM, so creating React applications usually requires the use of additional libraries for routing, as well as certain client-side functionality If you’re interested in a premium React course, both Tyler McGinnins and Wes Bos have great courses.

VUE

Vue.js (commonly referred to as Vue; pronounced /vjuː/, like "view") is an open-source model–view–viewmodel front-end JavaScript framework for building user interfaces and single-page applications.It was created by Evan You, and is maintained by him and the rest of the active core team members.

ANGULAR

Angular (commonly referred to as "Angular 2+" or "Angular CLI") is a TypeScript-based free and open-source web application framework led by the Angular Team at Google and by a community of individuals and corporations. Angular is a complete rewrite from the same team that built AngularJS.

Angular is used as the frontend of the MEAN stack, consisting of MongoDB database, Express.js web application server framework, Angular itself (or AngularJS), and Node.js server runtime environment.

NOW THE BIG QUESTION "WHICH FRAMEWORK SHOULD I LEARN OR WHICH IS THE BEST?

You might be wondering now, “Ok, well, which framework is the best?”
The truth is, they are all good. In web development, there’s almost never a single choice that is 100% the best choice for every person and every situation.
Your choice will most likely be determined by your job, or simply by which one you enjoy using the most. If your end goal is to land a job, try researching which framework seems to be the most common in potential job listings.
Don’t worry too much about which framework to choose. It’s more important that you learn and understand the concepts behind them. Also, once you learn one framework it will be easier to learn other ones (similar to programming languages).

4B: BASIC BACK-END

The back-end, or the server-side of web development, is made up of three main components: the server, a server-side programming language, and the database.

THE SERVER

As we mentioned at the very beginning, the server is the computer where all the website files, the database, and other components are stored.
Traditional servers run on operating systems such as Linux or Windows. They’re considered “centralized” because everything–the website files, back-end code, and data are stored together on the server.
Nowadays there are also serverless architectures, which is a more decentralized type of setup. This type of application splits up those components and leverages third party vendors to handle each of them.
Despite the name, though, you still do need some kind of server, to at least store your website files. Some examples of serverless providers are AWS (Amazon Web Services) or Netlify.
Serverless setups are popular because they are fast, cheap, and you don’t need to worry about server maintenance. They’re great for simple static websites that don’t require a traditional server-side language. However, for very complex applications the traditional server setup might be a better option.
To learn more about serverless setups, Netlify has an informative blog post that takes you through all the steps to setup a static website with deployment.

BACKEND PROGRAMMING LANGUAGE

On the server, you need to use a programming language to write the functions and logic for your application. The server then compiles your code and conveys the result back to the client.
Popular programming languages for the web include PHP, Python, Ruby, C# and Java. There is also a form of server-side JavaScript– Node.js, which is a run-time environment that can run JavaScript code on the server.

LET'S CHECK OUT A LIST OF THE MOST COMMONLY USED PROGRAMMING LANGUAGES FOR BACKEND WEB DEVELOPMENT

C

C# was developed as Microsoft’s competitor to Java. It’s used to make web apps with the .NET framework, game development, and can even be used to create mobile apps.

JAVA

Java is one of the most popular programming languages, and is used in web apps as well as to build Android apps.

NODE.JS

Node.js is a very popular technology (according to Stack Overflow’s 2019 developer survey). One thing to note: it isn’t technically a server-side language– it’s a form of JavaScript that runs on the server using the Express.js framework.

PHP

PHP is the language that powers WordPress, so this might be a good choice if you think you will be working with small business websites, as many of them use WordPress. You can also build web apps with the Laravel framework.

PYTHON

Python is growing in popularity, especially as it is used in data science and machine learning. It’s also considered to be good, as its syntax is simpler than some other languages. If you want to build web apps, you can use the Django or Flask frameworks.

RUBY

Ruby is another language that has a syntax considered to be fun to learn. You can build web apps with the framework Ruby on Rails.

NOTE

Just like with the JavaScript frameworks, there’s no #1 best programming language. Your choice should be based on either your personal interest and preference, as well as potential jobs– so do a little research on which might be a good choice for you.

DATABASE

Databases, as the name implies, are where you store information for your website. Most databases use a language called SQL (pronounced “sequel”) which stands for “Structured Query Language.”
In the database, data is stored in tables, with rows sort of like complex Excel documents. Then you can write queries in SQL in order to create, read, update, and delete data.
The database is run on the server, using servers like Microsoft SQL Server on Windows servers, and MySQL for Linux.
There are also NoSQL databases, which store the data in JSON files as opposed to the traditional tables. One type of NoSQL database is MongoDB, which is often used with React, Angular, and Vue applications.
Some examples of how data is utilized on websites are:
If you have a contact form on your website, you could build the form so that every time someone submits the form, their data is saved onto your database.
You can also user logins on the database, and write logic in the server-side language to handle checking and authenticating the logins.

CONCLUSION

A few tips that I have if you are going the self-taught route:

Don’t try to learn everything at once. Pick one skill to learn at a time.
Don’t jump around from tutorial to tutorial. As you’re learning, it’s ok to check out different resources to see which one you like best. But again, pick one and try to go all the way through it.
Know that learning web development is a long-term journey. Despite the stories you may have read of people going from zero to landing a web dev job in 3 months, I would aim more at 1 to 2 years to become job ready, if you’re starting from the beginning.
Just watching a video course or reading a book won’t automatically make you an expert. Learning the material is just the first step. Building actual websites and projects (even just demo ones for yourself) will help you to really cement your learning.

REFERENCES

https://www.freecodecamp.org/news/beginners-roadmap-web-development/
https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web
Credit:
Jessica Chan

Getting started With Open Source

MFONIDO MARK — Sun, 02 Jan 2022 21:23:34 +0000

OVERVIEW

Open source is a term that originally referred to open source software (OSS). Open-source software is code that is designed to be publicly accessible—anyone can see, modify, and distribute the code as they see fit. Open source refers to source code that is made available to the public to view, use, modify, and distribute under a license. It’s usually developed and maintained collaboratively by a community of its users. Some well-known open-source projects include Django, Postgres, MongoDB, Vue, Go, Ruby, TypeScript, Git and so many more.

WHY OPEN SOURCE

There is a variety of good reasons to release something under an open-source license, from “more perspectives make better software” to “establishing a standard.” It is important to build a sustainable project to consider your reasons for publishing as open-source and use these as guidance for decision making. Although the main point of open source projects is to create valuable and accessible open-source software, individual contributors can get plenty of personal benefit from contributing to them. You help maintain the software you use while honing your technical skills. When you’re applying for jobs, you can point to your work on open source software as proof of your skills.
"Open source code is written by developers and for developers."
To protect all the parties engaged in open source, the project owner can use a Creative Commons license. A Creative Commons (CC) license enables everyone to share, use, and build upon their work.

Open Source Vs Closed Source

OPEN-SOURCE

Open source refers to source code that is made available to the public to view, use, modify, and distribute under a license. It’s usually developed and maintained collaboratively by a community of its users.

CLOSE SOURCE

By contrast, there is proprietary software, also called “closed source software”. The source code of such a program can be inspected or altered only by its owners. Some examples of proprietary software include some products of Microsoft, Adobe, or Apple.

The benefit of Contributing to Open Source

PERSONAL BENEFITS

If I say that open source developers are driven by altruism and the desire to help others, a lot of people reading this article may smile in disbelief. But this intrinsic motivation is the primary reason most people work on open source projects.
Don't underestimate the importance of personal benefits – those feelings of being helpful and self-accomplished.

COMMUNITY RECOGNITION

Scientists and doctors share their experiences by writing scholarly articles and participating in scientific conferences. UI/UX designers share their experience on Behance or Dribbble. Writers print their books or share them via online platforms. Musicians and movie-makers share their work with the world via different streaming services. Why would software developers be any different and want to miss their opportunity to get recognition?
When working on or running open-source projects, you can get recognition from the developer community in several ways, such as creating a great GitHub profile and participating in events like Hacktoberfest.
You might also get discounts, free admissions to events, and a well-developed infrastructure to run your projects. Not only does working on open source projects save you money, but also it inspires you to use all the greatest tools available to you in your projects.

SELF ADVERTISING

If you or your company actively participate in the open-source community, you can earn a great reputation. This way, if you are an individual or self-employed developer, it will be easier for you to find a job as a freelancer or a full-time employee. If you represent a software development company, it will be easier for you to find people willing to work for you, partners willing to cooperate, and clients willing to request your professional services. This is why developing open-source software creates a perfect advertising opportunity – a win-win situation both for developers and development agencies.

SENSE OF VALUE

No need to hide the truth: job burnout plagues developers’ work and software vendors’ HR strategies. If you are a company owner, by motivating your employees to participate in open source development, you show them that their work has value. Not only will they be working on your commercial projects but they will also be providing value to the wider developer community by working on open source projects. By helping your developers achieve these feelings of purpose and value, you keep them interested in working with you. The same is true if you are a self-employed developer. Engaging in open source software development will make your work meaningful, and you will not grow to hate it as time passes.

SOFTWARE QUALITY

Open source code is often of higher quality. A piece of software created by a team of developers can be of lower quality than that developed by thousands of developers from all over the world with experience in different technologies, industries, and projects. And bugs in open source software are identified very quickly as the code is being constantly reviewed by multiple developers. Even code written by a single developer is often higher quality if it is open-sourced. If you write code that only you or your close colleagues will see, you may not care much about code style. But if you write code that everyone can see, you will do all you can not to look like a code monkey. Reviews, contributions, and refactoring from the community are all helpful here.

SUMMARY

The importance and benefits of Open Source cannot be overemphasized, when it comes to building quality software and writing good codes, even the personal gain you get from participating in open source projects.

HAVING YOUR FIRST MEETUP

MFONIDO MARK — Sat, 19 Dec 2020 07:05:29 +0000

Introduction
Launching a developer community begins with a well-organized first meetup. This event serves as a foundation for fostering collaboration, engagement, and long-term participation. It provides an opportunity for both existing and potential members to understand the mission, objectives, and benefits of being part of the developer circle.

A successful first meetup should be well-planned, engaging, and inclusive, setting the right expectations for future activities. Below is a structured plan to ensure the event is impactful and runs smoothly.

Key Planning Considerations

Meetup Purpose and Theme The first step in organizing the meetup is defining its purpose and theme. This ensures clarity for attendees and helps guide event activities. The theme should align with the community's goals and be compelling enough to attract participants.

Example Theme:
📌 "Info Session: Building an Inclusive and Impactful Developer Community"

This theme communicates that the event will focus on introducing the community’s mission, engaging with developers, and highlighting the benefits of participation.

✅ Key Considerations:

Ensure the theme is clear and relevant to the audience.
Make the purpose explicit in event promotions and descriptions.
Align the theme with long-term community-building goals.

Structuring the Agenda A well-organized agenda helps maintain the flow of the event, keeps participants engaged, and allows for smooth transitions between activities.

Suggested Agenda:

Welcome & Introduction – Brief overview of the event and objectives.
Keynote Session – A speaker discussing the importance of developer communities.
Community Vision & Goals – Explaining what the developer circle aims to achieve.
Break & Networking – Interactive session for participants to connect.
Panel Discussion – Experts discussing challenges and opportunities in tech communities.
Fun Activity / Icebreaker – A short game or activity to boost engagement.
Q&A Session – Addressing attendees' questions.
Closing Remarks – Summary of key takeaways and next steps.
✅ Key Considerations:

Balance formal discussions with interactive and engaging activities.
Allow flexibility to accommodate unforeseen delays.
Ensure time for networking to foster connections among attendees.

Selecting the Date and Time Choosing the right date and time is crucial to maximize participation. A poorly scheduled event may lead to low turnout.

✅ Best Practices for Scheduling:

Understand the audience’s availability: Consider weekends or evenings if most members work during the day.
Avoid conflicting events: Check for industry conferences, holidays, or other major events.
Allow adequate planning time: Announce the event at least two weeks in advance to build anticipation.
Optimize duration: Keep the event between 2 to 3 hours to maintain engagement.
Example:
📅 Saturday, 3:00 PM – 6:00 PM (local time), ensuring a balance between flexibility and convenience.

Choosing the Right Venue The venue plays a significant role in the success of the meetup. It should be accessible, comfortable, and conducive to discussions.

✅ Key Considerations:

Location Accessibility: Choose a central location with good transportation links.
Seating & Comfort: Ensure the venue can accommodate the expected number of attendees.
Technology & Facilities: Check for audio-visual equipment, internet access, and power outlets.
Booking Confirmation: Secure and confirm the venue at least two days before the event to avoid last-minute issues.
Safety & Security: Ensure the venue is in a safe area with appropriate security measures.
📍 Example Venue: A co-working space, tech hub, or university hall with adequate facilities.

Selecting Speakers The quality of speakers can greatly influence the success of the meetup. Engaging and knowledgeable speakers help establish credibility and keep attendees interested.

✅ Ideal Speaker Profile:

Experienced in developer communities or tech advocacy.
Skilled in public speaking and audience engagement.
Knowledgeable about inclusivity and community building.
💡 Example Speakers:

A local tech influencer or industry expert.
A representative from a well-established developer community.
A founder or team lead from a successful startup.

Event Promotion & Outreach To ensure a good turnout, the event needs strong promotion through multiple channels.

✅ Promotion Strategies:

Social Media Campaigns: Utilize Twitter, LinkedIn, Facebook Groups, and Instagram.
Community Engagement: Share announcements in developer forums, WhatsApp, Telegram, and Slack groups.
Email Marketing: Send reminders to registered attendees.
Paid Advertisements: Use Facebook Ads for broader reach if necessary.
Word of Mouth: Encourage early registrants to invite peers.
📌 Best Practice: Start promotions at least two weeks before the event and increase engagement as the date approaches.

Selecting Relevant Topics The topics covered should cater to a diverse audience, especially beginners. Overly technical discussions may alienate non-experts.

✅ Recommended Topics:

The Importance of Developer Communities
How to Build an Inclusive and Supportive Tech Circle
Types of Developer Communities and Their Benefits
Leveraging Communities for Career Growth
These topics ensure the session remains beginner-friendly and engaging.

Providing Refreshments For events lasting more than 2-3 hours, providing light refreshments helps keep attendees comfortable and focused.

✅ Best Practices:

Offer simple snacks like sandwiches, pastries, or fruit.
Provide water, coffee, or juice to keep attendees hydrated.
Consider sponsorships from local businesses or cafes to offset costs.
Final Checklist for a Successful Meetup
✔ Define a clear theme and purpose.
✔ Create a structured agenda with engaging sessions.
✔ Choose a suitable date and time.
✔ Secure an accessible and comfortable venue.
✔ Invite knowledgeable and engaging speakers.
✔ Promote the event effectively using multiple channels.
✔ Select beginner-friendly and relevant discussion topics.
✔ Ensure refreshments are available for attendees.

Conclusion
A well-organized first meetup sets the tone for future community engagement. By carefully planning the event’s theme, agenda, logistics, and promotion, organizers can create a welcoming environment that encourages participation and fosters a strong developer network.

By following these structured steps, your first meetup will not only be successful but will also lay the groundwork for a thriving and engaged developer community.

🚀 Let’s build something amazing together!

OBJECTIVES AND KEY RESULTS

MFONIDO MARK — Fri, 31 Jul 2020 06:50:18 +0000

OKR

In business, OKRs are used to guide outcome-based success. Using outcomes instead of tasks as a driver, OKRs encourage accountability in every step of achieving success through metric indicators. OKRs are driven by values-based outcomes. So for the sake of our settings we shall be looking at OKR’s in the tech ecosystem(community). We shall try as much as possible to simplify it to its barest minimum.

WHAT IS OKR?

OKR (Objectives and Key Results) is a goal setting system used by Google and other companies. It is a simple approach to create alignment and engagement around measurable and ambitious goals. OKRs are frequently set, tracked, and re-evaluated – usually quarterly. OKR is a simple, fast-cadence process that engages each team’s perspective and creativity.

Understanding the OKR Components.

John Doerr is one of the most successful venture capitalists of all time. He started his career at Intel and went on to invest in companies such as Google and Amazon. Doerr, who introduced Google to OKR, has a formula for setting goals:
A proper goal has to describe both what you will achieve and how you are going to measure its achievement. The key words here are “as measured by,” since measurement is what makes a goal a goal. Without it, you do not have a goal, all you have is a desire. Doerr’s formula is the best way to explain the structure of an OKR:

I will (Objective) as measured by (this set of Key Results).

So, as the name implies, OKR has two components, the Objective and the Key Results:

Objectives are memorable qualitative descriptions of what you want to achieve. Objectives should be short, inspirational and engaging. An Objective should motivate and challenge the team.

Key Results are a set of metrics that measure your progress towards the Objective. For each Objective, you should have a set of 2 to 5 Key Results. More than that and no one will remember them.

All Key Results have to be quantitative and measurable. As Marissa Mayer, a former Google’s Vice President, said:

“If it does not have a number,
it is not a Key Result.”

OKRS OCCUR RHYTHMICALLY

Following a cyclical planning cadence, the focus of goals moves from tasks to results, keeping priorities and everyone’s thinking disciplined.

A SUPPORTIVE ATMOSPHERE IS CREATED

Success isn’t just about reaching goals, but also about creating a culture of coaching. OKRs enable accurate communication.

EVERYONE IS ACCOUNTABLE

Being more than a declaration to accomplish a project, teams using OKRs figure out what really matters, together.

Example One

First of all, we need an Objective. An example might be “Create an Awesome Client Experience.” This sounds great, but how would you know if the experience is awesome? Remember, without measurement you don’t have a goal.

That is why we need Key Results. How can we measure if we are providing an awesome client experience? Net Promoter Score and Repurchase Rate would be two good options. Do our client feel so good about dealing with us that they would recommend us?. But measuring NPS and repeat purchases alone can send the wrong message. It might encourage us to make the customer happy at any cost. Therefore, we can include a countermeasure such as Customer Acquisition Cost. We want to make our customers happy while keeping the costs under control.

NPS:
Net Promoter or Net Promoter Score is a management tool that can be used to gauge the loyalty of a firm's customer relationships. It serves as an alternative to traditional customer satisfaction research and is claimed to be correlated with revenue growth.

The complete example would be:

Objective:
Create an Awesome Client Experience

Key Results:
➔ Improve Net Promoter Score from X to Y.
➔ Increase Repurchase Rate from X to Y.
➔ Maintain Client Acquisition cost under Y. (Customer Acquisition Cost is the cost of winning a customer to purchase a product/service. As an important unit economic, customer acquisition costs are often related to customer lifetime value.)

Example Two
Now consider a team that wants to increase the engagement with a digital service:

Objective:
Delight our client

Key Results:
➔ Reduce revenue churn (cancellation) from X% to Y%.
➔ Increase Net Promoter Score from X to Y.
➔ Improve average weekly visits per active user from X to Y.
➔ Increase non-paid (organic) traffic to from X to Y.
➔ Improve engagement (users that complete a full profile) from X to Y.

Once more having a set of Key Results helps create a healthy, sustainable OKR. We want to increase the weekly visits, but we want it to be organic, not through an expansion of marketing spend.
Key Results are crucial. Most of all, they define what we mean by “Delight our customers.”
A second team or company could use the same Objective with different Key Results.

What’s unique about OKR?
There is not a single way to use OKR, each company or team can adapt and tweak it, creating different versions of it. But there are some core concepts:

Agile Goals
Instead of using annual static planning, OKR takes an agile approach. By using shorter goal cycles, companies can adapt and respond to change.

Simplicity
Using OKR is straightforward, and the OKRs themselves are easy to understand. Intel’s original model set goals monthly, which required a lightweight process. Companies that adopt OKR reduce the time spent setting goals from months to days. As a result, they invest their resources in achieving their goals and not on setting them.

Transparency
The primary purpose of OKR is to create alignment in the organization. To do so, OKRs are public to all company levels — everyone has access to everyone else’s OKRs. The CEO’s OKRs usually are available on the Intranet.

Nested Cadences
OKR understands that strategy and tactics have different natural tempos since the latter tends to change much faster. To solve this, OKR adopts different rhythms:

➔A strategic cadence with high-level, longer term OKRs for the company (usually
annual).
➔ A tactical cadence with shorter term OKRs for the teams (usually quarterly).
➔ An operational cadence for tracking results and initiatives (usually weekly).

Bidirectional Goal Setting
Instead of using the traditional top-down cascading model that takes too much time and does not add value, OKR uses a market-based approach that is simultaneously bottom-up and top-down. From the company’s strategic OKRs, teams can understand how they can contribute to the overall strategy. In this process, around 60% of the tactical OKRs are set by the teams in alignment with the company goals and then contracted with the managers in a bubble-up approach. This model creates engagement and a better understanding of the strategy while making the process simpler and faster.

Ambitious Goals
The philosophy behind OKR is that if the company is always reaching 100% of the goals, they are too easy. Instead, OKR targets bold, ambitious goals. Besides aspirational objectives, OKR believes in enabling the team to set challenging goals. Goals that make the team rethink the way they work to reach peak performance.

Decoupling Rewards
Separating OKRs from compensation and promotions is crucial to enable ambitious goals. Employees need to know they will not lose money if they set ambitious goals. It is hard to set ambitious goals when you need the bonus to pay for your kids’ college tuition.
OKR is a management tool, not an employee evaluation tool.

BENEFIT OF USING OKR

The main advantages of using OKR are:

Agility
Shorter goal cycles enable faster adjustments and better adaptation to change,increasing innovation and reducing risks and waste.

Alignment and cross-functional cooperation
The use of shared OKRs improves collaboration among different teams, solving interdependencies and unifying competing initiatives.

Reduced time for setting goals
OKR simplicity makes the goal setting process faster and easier, drastically reducing the time and resources spent on setting goals.

Clear communication
Transparency and simplicity enable the team to understand the goals and priorities of the organization as well as how each individual can contribute.

Employee engagement
OKR bottom-up approach for goal setting connects the employees with the company’s objectives, increasing engagement.

Autonomy and accountability
Teams receive a clear direction and are free to choose how to achieve their OKRs. They become responsible for their objectives, with clear success criteria known to the whole company, creating mutual obligations.

Focus and discipline
The reduced number of goals creates focus in the organization and more disciplined efforts and initiatives.

Bolder goals
Decoupling OKRs from compensation and using stretch goals, even partially, enable the team to set ambitious, challenging goals.

IN SUMMARY
So, Technically, OKR helps you set company, department, team, and personal goals. You connect each goal with 3-5 measurable results. As you achieve those results, the percentage of the entire Objective increases, so you can see the progress towards your aspirational goals and know if you are getting better or worst.

'Focus' is the most important step. You should only have 3-5 Objectives,as having more will make it hard for you to track you successes. Therefore, OKRs help you figure out what's most important (priorities items for you) and how work at every level connects to your most important goals.

So, i hope this article have given you a little push when next you have a project or your team needs to meet a specific objectives, you now know how to achieve it better and stronger.

INCLUSIVE COMMUNITY

MFONIDO MARK — Fri, 10 Jul 2020 07:50:01 +0000

INCLUSIVE COMMUNITY

There is a need for building communities, be it for any purpose, be it a school, religious, or social communities. The need for community building can not be over emphasis, as this encourages growth among individuals and group of people.

What is a community?
A community is a social unit with commonality such as norms, religion, values, customs, or identity. Communities may share a sense of place situated in a given geographical area or in virtual space through communication platforms. (Wikipedia).

The word INCLUSIVE.
The definition of inclusive is something that does not leave any part or group out.

What is INCLUSIVE COMMUNITY?
An inclusive community is a community that over-rides differences of race, gender, class,
generation, and geography, and ensures inclusion, equality of opportunity as well as
capability of all members of the society to determine an agreed set of social institutions
that govern social interaction. (Expert Group Meeting on Promoting Social Integration,
Helsinki, July 2008).

WHY BUILD AN INCLUSIVE COMMUNITY?
Just as everyone needs love and friendship and an opportunity to contribute, everyone needs community. We all need to know and believe that we belong to something bigger. Whether it is family, friends at work, Religious affiliation or the gym; it is comforting and healthy to be surrounded by people with whom we are familiar; whom we care about and who care about us. Equally, no matter “who” you are, “how” you are or what you’ve been told, you are important. You have something unique to contribute. You have a talent, a skill, an interesting insight or story to share. Just by accessing and giving to the community, you bring a unique and necessary perspective to the social conversation, one based on your individual experiences: how you’ve gotten around and interacted with the world, what you’ve been taught and how you’ve been treated. Without you, your perspective and the contributions that you bring, the community is diminished. The Community, to be all it can be, needs you. It needs everyone.

REASONS:
• Mold the values of the next generation of Developers
• Provides opportunities for friendships
• Prepares individuals for adult life in the community
• Maintains a typical family structure to life
• Cultivates an enriched learning environment
• Acts of exclusion and injustice based on group identity and other factors should not be allowed to occur and/or continue.
• All people have the right to be part of decisions that affect their lives and the groups they belong to.
• Diversity enriches our lives, so it is worth our while to value our community's diversity.

BEING “IN” VERSUS BEING “OF” THE COMMUNITY
This all sounds great but there is a problem … and it has to do with whether or not one has the opportunity to truly and fully participate; to contribute. It has to do with the fundamental difference between being “in” the community and being “of” the community. Anyone can be “in” the community. We can go to the store, live in an apartment, attend school or church and be “in” the community, but still not be “of” the community. Being “of” the community is much more complicated. Unfortunately, it requires a status of “member” be “bestowed” upon the person or group by a majority of the community. It requires membership be recognized, validated and supported by law makers, educators, employers, public and social service, housing, and medical providers, by the various religious communities and by the general population.
Anything short of this broad acceptance, this whole new way of thinking, and we remain marginalized, perhaps “in” but not “of” community. We remain without a sense of belonging or “real” connection, no sense of equity. Without equity, without voice, we (and our communities) have less chance of developing wholly and healthily. Opportunities to participate become less possible and those left out can only struggle against continued marginalization.

HOW TO SUPPORT INCLUSION.
Many times an inclusive environment is not readily available to people. However this does not preclude the possibility of achieving an inclusive environment for your community. Below are ways to create and support an inclusive community environment.

• Develop a vision for your community inclusion and be able to get others excited about the opportunity.
• Begin early in order to give yourself proper time to accomplish your goal.
• Develop a network of resources: 
    ◦ Professionals and teachers who support your vision
    ◦ Consultants with expertise in inclusion
    ◦ Examples of other members who are being successfully included
• Facilitate communication between the various community members involved with your community. Helping to ensure everyone is connected and that concerns are addressed can make a non-traditional inclusive setting work more effectively.
• Consider the use of grant money to support your efforts. Various business and not-for-profit organizations may have money available to support individuals in an inclusive setting.

In Summary
The work of building inclusive communities is not easy; results will not occur overnight. It takes time, patience, perseverance, and courage, because this work is about transforming attitudes, behaviors, and policies. It requires strategies that operate at multiple levels, including the individual, group, and institutional levels.