DEV Community: Sonu Sharma 💙

Open Source vs Closed Source: The Pros and Cons

Sonu Sharma 💙 — Sat, 10 Jun 2023 07:52:04 +0000

Introduction

When it comes to software development, there are two types of software: open source and closed source. Open source refers to software whose source code can be accessed, modified and shared by anyone, while closed source refers to software whose source code cannot be accessed by anyone outside of the company who created it. Both types of software have their own advantages and disadvantages, and it's important to understand them before deciding which one to use.

Pros of Open Source Software

1. Flexibility: Open source software is highly flexible, as the source code is freely available to anyone who wants to modify it. This allows developers to customize the software to fit their own specific needs and requirements.

2. Cost-effective: Open source software is often significantly less expensive than closed source software. This is because open source software can be freely distribut
ed, and there are often no licensing fees associated with it.

3. Transparency: Because the source code is open, there is greater transparency in how the software works. This means that anyone can look at the code to see how the software is built, and can identify any bugs or flaws that need to be fixed.

4. Community: Open source software is built by a community of developers who work together to improve the software. This means that there is a wealth of knowledge and experience available to those who use it.

Cons of Open Source Software

1. Learning curve: Open source software often has a steeper learning curve than closed source software, as it requires more technical knowledge to use and modify.

2. Support: Although there is a community of developers that work together to improve open source software, there may not be an official support system available. This means that users may have to rely on forums or other online resources for help.

3. Security: Open source software is vulnerable to security threats, as anyone can access and modify the source code. While the community of developers often works to identify and fix security vulnerabilities, it is still possible for malicious developers to introduce security threats.

Pros of Closed Source Software

1. Ease of use: Closed source software is often easier to use than open source software, as it is designed to be user-friendly and intuitive.
2. Support: Because a company owns closed source software, they are often able to provide a dedicated support system for users.

3. Security: Closed source software is often more secure than open source software, as the source code is not freely available to everyone. This means that malicious developers cannot easily introduce security threats.

4. Intellectual property protection: A company that owns closed source software is able to protect their intellectual property through patents and copyrights.

Cons of Closed Source Software

1. Cost: Closed source software is often more expensive than open source software, as licensing fees are required.

2. Lack of flexibility: Because the source code is not available to everyone, closed source software is often less flexible than open source software.

3. Dependence: Users of closed source software are dependent on the company that owns the software, as they are the only ones who can make changes to the software.

Conclusion

In conclusion, both open source and closed source software have their own advantages and disadvantages. It is important for developers to carefully consider both options before making a decision on which one to use. While open source software offers greater flexibility and cost-effectiveness, closed source software offers greater ease of use and security. Ultimately, the decision will depend on the specific needs and requirements of the developer or business.

The Rise of Low-Code Development: What You Need to Know

Sonu Sharma 💙 — Thu, 25 May 2023 04:53:19 +0000

In recent years, low-code development has emerged as an innovative solution to the problem of overly complex software development. This approach makes app development more accessible, productive, and faster. Low-code development has the potential to revolutionize the way software is developed, deployed, and maintained. If you are not sure what low-code development is all about, do not worry. In this article, we will explain everything you need to know about this exciting new trend.

Defining Low-Code Development

Low-code development is an approach to software application development that requires minimal coding effort. Instead of writing code from scratch, developers use pre-built components and drag-and-drop interfaces to create applications quickly. This methodology aims to make application development more accessible for non-programmers, increase productivity and reduce development times, and improve maintenance.

The Importance of Low-Code Development

Software application development has traditionally been time-consuming, expensive, and complex, requiring a high level of technical expertise. Low-code development solves these problems by making app development fast, cost-effective, and less technically challenging.

Advantages of Low-Code Development

Low-code development offers several advantages over traditional coding approaches, including:

Faster Development Time - Low-code enables developers to create applications faster owing to the reuse of pre-built components for coding.
Easy to Learn - Low-code development makes it easier to understand coding concepts for non-developers with the drag-and-drop building block feature, which makes it possible to code without the need for a development background.
Increased Productivity - Using a low-code approach, developers can work with more productivity, and the software development lifecycle significantly improves.
Reduced Technical Complexity - Low-code uses pre-built blocks that allow easy creation of applications with less technical code.
Improved Collaboration - Low-code platforms allow non-technical team members to contribute to the application development process, making the software creation team more diverse and inclusive.

The Future of Low-Code Development

Low-code development is a rapidly growing trend, and the demand for low-code software development is forecasted to increase. As the number of businesses reliant on software applications for their everyday operations grows, low-code development can offer the solution they need to increase their operational efficiency and customer satisfaction.

Conclusion

Low-code development is gaining momentum as one of the most innovative and approachable ways to create software applications. The advantages of low-code development, including the reduced complexity, faster development timeline, and ease of use, make it an integral approach to software development, particularly for non-technical developers. Due to its successes, low-code development is projected to grow significantly in the years to come, and businesses that adopt it to drive their software development will be well placed as the industry evolves.

Tips and Tricks That Every Typescript Developer Should Know

Sonu Sharma 💙 — Sun, 21 May 2023 12:04:17 +0000

Tips and Tricks for TypeScript Developers

TypeScript has become the go-to language for building scalable web applications in recent years. It is a superset of JavaScript that offers static typing and a host of other features, making it easier to write code that is less error-prone and more maintainable.
If you are a TypeScript developer or looking to become one, here are some tips and tricks you should know to enhance your development.

1. Embrace the Type System

one of the primary advantages of typescript is its type system, which allows you to catch potential bugs at compile-time. Ensure that you take advantage of the type system in TypeScript by thoroughly annotating your types.

Example:

function add(a: number, b: number): number {
   return a + b;
}

2. Use Generics

Generic types allow you to write reusable code that can adapt to different types easily. This feature can save you time and lines of code by allowing you to define functions and classes that work with multiple data types.

Example:

interface IProduct<T> {
  id: string;
  name: string;
  price: T;
}


const product: IProduct<number> = {
    id: '1234',
    name: 'Product Name',
    price: 500,
};

3. Take Advantage of Enums

An enum is a type of data that allows a variable to have one of several predefined values. They help you keep your code maintainable and easy to understand by defining a set of related values.

Example:

enum Direction {
  LEFT,
  RIGHT,
  UP,
  DOWN,
}

let direction = Direction.LEFT;

4. Use Intersection Types

Intersection types allow you to merge multiple types into a single type.

Example:

type X = {
  x: string;
};

type Y = {
  y: string;
};

type XY = X & Y;

const xy: XY = { x: 'hello', y: 'world' };

5. Use Optional Chaining

Optional chaining allows you to access nested properties or methods without having to check if each level exists.
Example:

const name = user?.firstName ?? 'Unknown';

6. Use Nullish Coalescing

Nullish coalescing allows you to provide a default value when a value is null or undefined.
Example:

const name = user.firstName ?? 'Unknown';

7. Use Read-Only Properties

Read-only properties ensure that a property value cannot be changed after it is instantiated, including in constructors.
Example:

class Person {
  readonly name: string;

  constructor(name: string) {
    this.name = name;
  }
}

8. Use Destructuring

Destructuring allows you to extract values from objects and arrays into separate variables.
Example:

const { firstName, lastName } = user;

9. Use Type Aliases

Type aliases allow you to create a name for a type that is used multiple times.
Example:

type User = {
  firstName: string;
  lastName: string;
};

function greet(user: User) {
  console.log(`Hello, ${user.firstName} ${user.lastName}`);
}

10. Use Type Assertions

Type assertions allow you to tell TypeScript to treat a value as a specific type in specific situations.
Example:

const x: unknown = 'hello world';
const y = (x as string).toUpperCase();

11. Use the never Type

The never type represents a value that will never occur.
Example:

function fail(message: string): never {
  throw new Error(message);
}

12. Use the Spread Operator

The spread operator allows you to create a new array or object by merging existing ones.
Example:

const numbers = [1, 2, 3];
const newNumbers = [...numbers, 4, 5, 6];

13. Use Union Types

Union types allow you to define a type that can have one of several types.
Example:

type Status = 'success' | 'failure';

function getStatus(status: Status) {
  console.log(`status is ${status}`);
}

14. Use Enums for String Literals

Enums can also be used to define string literals.
Example:

enum Status {
  Success = 'Success',
  Failure = 'Failure',
}

function getStatus(status: Status) {
  console.log(`status is ${status}`);
}

15. Use keyof to get Keys of Objects

The keyof keyword allows you to get the keys of an object.
Example:

type User = {
  firstName: string;
  lastName: string;
};

const keys: Array<keyof User> = ['firstName', 'lastName'];

16. Use typeof to get the Type of a Variable

The typeof keyword allows you to get the type of a variable at runtime.
Example:

const x = 10;
const y: typeof x = 20;

17. Use in Operator For Checking Properties of Objects

The in operator allows you to check if a property exists on an object.
Example:

type User = {
  firstName?: string;
  lastName?: string;
};

function greet(user: User) {
  if ('firstName' in user) {
    console.log(`Hello, ${user.firstName}`);
  } else {
    console.log('Hello');
  }
}

18. Use String Interpolation

String interpolation allows you to embed expressions in string literals.
Example:

const firstName = 'John';
const lastName = 'Doe';
console.log(`Hello, ${firstName} ${lastName}`);

19. Use typeof for Type Guards

Using typeof in conjunction with if-else statements can serve as an alternative to type guard syntax.
Example:

function example(foo: string | number): void {
  if (typeof foo === 'string') {
    console.log('string');
  } else {
    console.log('number');
  }
}

20. Use export * as to Re-Export Modules

The export * as syntax allows you to re-export all named exports of a module under a separate namespace.
Example:

// module1.ts
export const foo = 1;
export const bar = 2;

// module2.ts
export * as module1 from './module1';

21. Use Tuples for Fixed-Length Arrays

Tuples allow you to define an array with a fixed number of elements, with different types.

Example:

const tuple: [number, string] = [1, 'hello'];

22. Utilize TSLint

TSlint is a tool that provides linters for TypeScript, statically analyzing the code and providing guidelines on how to improve the quality of the codebase, resulting in cleaner and quality code.

Example:

 npm install -g tslint

Conclusion

The techniques discussed in this article are a good starting point for becoming a Typescript developer, knowing the basics will save one a lot of shoot-my-foot moments during the code review and debugging phase.
These are just a few tips and tricks that can greatly improve your development with TypeScript. Other options include applying object-oriented approaches and utilizing external libraries correctly. By applying these techniques and more, you can employ the full capabilities of TypeScript, building robust, scalable applications.

Top 10 Best Practices for Coding That Every Developer Should Follow

Sonu Sharma 💙 — Sat, 20 May 2023 03:51:45 +0000

Coding is an essential part of software development, and it is essential to write clean, efficient, and maintainable code. In this article, we will discuss the top 10 best practices that every developer should follow while coding.

Following these best practices can help you to produce high-quality code that is easy to read, debug, and maintain.

1. Write Readable Code

Writing readable code is the most crucial aspect of coding. Your code should be easy to read and understand, and other developers should be able to follow it.One of the best ways to write readable code is to use appropriate naming conventions for variables, functions, classes, and so on.

Example

// ❌ Poorly written code
let x = [2, 3, 5, 7, 11, 13];
for (let i = 0; i < x.length; i++) {
  for (let j = i + 1; j < x.length; j++) {
    if (x[i] + x[j] === 14) {
      console.log(x[i], x[j]);
    }
  }
}

// ✅ Better written code
let primes = [2, 3, 5, 7, 11, 13];
for (let i = 0; i < primes.length; i++) {
  for (let j = i + 1; j < primes.length; j++) {
    if (primes[i] + primes[j] === 14) {
      console.log(primes[i], primes[j]);
    }
  }
}

By using appropriate naming conventions and formatting, the second block of code is much more readable and easier to understand than the first block of code.

2. Use Consistent Coding Style

Consistency in coding style is essential for a team of developers working on the same project. It saves time, reduces confusion, and improves the maintainability of the code. Adopt a coding style guide and stick to it.

Example

// ❌ Inconsistent coding style
function add(x, y) {
  return x+y;
}

// ✅ Consistent coding style
function add(x, y) {
  return x + y;
}

The second block of code has a consistent coding style, which makes it easier to read and understand the code.

3. Avoid Magic Numbers or Strings

Magic numbers or strings are hard-coded values in the code that can make it difficult to read and maintain. Use constants or variables to replace them to improve the readability and maintainability of the code.

Example

// ❌ Magic numbers and strings
function getArea(width, height) {
  if (width == 10 && height == 5) {
    return 50;
  }
  if (width == 5 && height == 10) {
    return 25;
  }
}

// ✅ Constants instead of magic numbers and strings
const WIDTH_1 = 10;
const HEIGHT_1 = 5;
const WIDTH_2 = 5;
const HEIGHT_2 = 10;

function getArea(width, height) {
  if (width == WIDTH_1 && height == HEIGHT_1) {
    return WIDTH_1 * HEIGHT_1;
  }
  if (width == WIDTH_2 && height == HEIGHT_2) {
    return WIDTH_2 * HEIGHT_2;
  }
}

By using constants instead of magic numbers or strings, the code becomes more self-explanatory and easier to understand.

4 Write Modular Code

Modular code makes the code more organized and enhances its maintainability. It is much easier to update or add new features to modular code than to spaghetti code. Break your code into smaller, easier-to-manage modules or functions that carry specific responsibilities.

Example

// Monolithic Code
function calculatePay(employee) {
    var pay = 0;
    if (employee.role == 'Manager') {
        pay = employee.salary + 1000;
    }
    if (employee.role == 'Developer') {
        pay = employee.salary;
    }
    if (employee.role == 'Tester') {
        pay = employee.salary - 1000;
    }
    return pay;
}

// Modularity
function calculatePay(employee) {
    return employee.salary + employee.bonus;
}

function getEmployeeBonus(role) {
    if (role == 'Manager') {
        return 1000;
    }
    if (role == 'Developer') {
        return 0;
    }
    if (role == 'Tester') {
        return -1000;
    }
}

function calculateEmployeeBonus(employee) {
    return (employee.salary * getEmployeeBonus(employee.role)) / 100;
}

function calculateTotalPay(employee) {
    return calculatePay(employee) + calculateEmployeeBonus(employee);
}

In this example, modular code is used to break up a monolithic function into smaller, easier to understand and maintainable functions.

5. Use Comments

Adding comments to your code is a great way to document your code and make it more understandable. Do not hesitate to add comments explaining why a particular piece of code has been written.

Example

// ❌ Poorly commented code
function add(x, y) { // function to add two numbers
  return x + y; // returns the sum of two numbers
}

// ✅ Better commented code
function add(x, y) {
  // This function accepts two numbers x and y
  // It returns the sum of x and y
  return x + y;
}

Adding comments that explain how the code works can help other developers understand and maintain the code.

6. Use Descriptive Function and Method Names

Using descriptive function and method names can make your code more readable by providing information about what a given function or method does.

Example

// ❌ Poor function and method names
function f(x, y) {
  for (let i = 0; i < x.length; i++) {
    if (x[i] == y) {
      return i;
    }
  }
  return -1;
}

class Foo {
  x() {}
}

// ✅ Descriptive function and method names
function indexOfItemInArray(array, item) {
  for (let i = 0; i < array.length; i++) {
    if (array[i] == item) {
      return i;
    }
  }
  return -1;
}

class Bar {
  getXCoordinate() {}
}

7 Use Version Control

Version control is one of the essential tools for managing code. Use a version control system like Git or SVN to keep track of changes to your code and to collaborate better with your team members.

Example

git init
git add .
git commit -m "Initial commit"
git push

Using a version control system like Git makes it easier to track changes, collaborate with team members and roll back changes when needed.

8. Use Debugging Tools

Debugging your code is an essential part of the development process. Make use of debugging tools provided by your integrated development environment (IDE) or use debugging libraries like Log4J and Apache for better error handling.

Example

function addNumbers(x, y) {
  return x + y;
}

const result = addNumbers(5, '7'); // Type Error

try{
  console.log(addNumbers(5, '7')); // Throws Type Error on console
}catch(error){
  console.log(error);
}

9. Test Your Code

Perform test cases to ensure the code is working correctly. Write unit tests and functional tests to identify errors at various stages of development. Adopt Test-Driven Development (TDD) to write tests before writing code.

Example

// Unit test example
function testAddNumbers() {
  if (addNumbers(2, 3) === 5 &&
      addNumbers(1, -1) === 0 &&
      addNumbers(0, 0) === 0 &&
      addNumbers(-1, -1) === -2) {
      return true;
    }
    return false;
}

// Functional Test Example
function testLogin() {
  if (login('admin', 'admin123') === true &&
      login('guest', 'password') === false) {
      return true;
    }
    return false;
}

10. Refactor Regularly

Refactoring is a technique used to improve the quality of code by cleaning up messy code. Refactor your code regularly to eliminate unnecessary dependencies, remove repetitive code and get rid of any potential bottlenecks.

Example

// ❌ Poorly written code with duplication and lots of statements
function calculateSalary(numberOfHours, hourlyPay, overtime, bonus) {
    let salary = 0;
    if (numberOfHours > 40) {
        if (overtime) {
            salary += (40 * hourlyPay) + (numberOfHours - 40) * hourlyPay * 1.5;
        } else {
            salary += 40 * hourlyPay;
        }
    } else {
        salary += numberOfHours * hourlyPay;
    }
    if (bonus) {
        salary *= 1.1;
    }
    return salary;
}

// ✅ Better written code without duplication and fewer statements.
function calculateSalary(numberOfHours, hourlyPay, overtime, bonus) {
    let salary = numberOfHours * hourlyPay;
    if (overtime && numberOfHours > 40) {
        salary += (numberOfHours - 40) * hourlyPay * 1.5;
    }

    if (bonus) {
        salary *= 1.1;
    }
    return salary;
}

Conclusion

Following these best practices can make a significant difference in the quality of code you produce. Writing clean and efficient code not only makes coding easier but also makes it more enjoyable.
It helps you avoid potential errors, reduce debugging time and improve the overall quality of your work.
By adopting these best practices, developers can achieve more efficient code development, reduce errors, and respond faster to new requirements. So, start implementing these best practices today and watch your code quality soar to new heights.

Thank you for taking the time to read my article! If you found the information helpful and would like to stay up-to-date on the latest programming tips and tricks,You can follow me on Twitter, LinkedIn, and GitHub, where I share articles, code snippets, and programming-related insights regularly. By following me, you will never miss out on any useful updates, and that way we can constantly improve our knowledge on programming together. Looking forward to seeing you in my social media community!

Bug: An Inevitable Part of the Development Process

Sonu Sharma 💙 — Tue, 07 Mar 2023 01:10:14 +0000

Introduction

Bugs are an inevitable part of the software development process. No matter how carefully code is written and tested, bugs will always arise. However, bugs can also play a crucial role in the development process, as they can help identify problems and improve the overall quality of the software.

Bugs can also serve as a learning opportunity for developers. By identifying and fixing bugs, developers can improve their understanding of the code and become more efficient at identifying and fixing problems in the future.

The Role of Bugs in Development

One of the primary roles of bugs in development is to identify problems in the code. When a bug is discovered, it can indicate that something is not functioning as intended. This can help developers identify and fix problems in the code, improving the overall quality and reliability of the software.

Different Types of Bugs

There are several types of bugs that can occur in software development:

1. Syntax errors: These are errors in the code that occur when the code does not conform to the syntax (grammar) of the programming language being used. Syntax errors can prevent the code from being compiled or executed.

2. Logic errors: These errors occur when the code is written correctly, but it does not produce the intended results. Logic errors may not be immediately apparent and can be difficult to detect and fix.

3. Run-time errors: These errors occur when the code is executed and cause the program to crash or produce unexpected results. Run-time errors can be caused by a variety of factors, such as invalid input, memory issues, or problems with external dependencies.

4. Resource leaks: These errors occur when a program does not release resources (such as memory or file handles) that it has acquired. This can lead to the program running out of resources and crashing.

5. Security vulnerabilities: These are vulnerabilities in the code that can be exploited by attackers to gain unauthorized access to the system or data. Security vulnerabilities can have serious consequences, so it is important to identify and fix them as soon as possible.

These are just a few examples of the types of bugs that can occur in software development. There are many other types of bugs that can arise, and the nature of the bug will depend on the specific code and environment in which it occurs.

Determining the Severity of a Bug

There are several factors to consider when determining the severity of a bug:

1. Impact on functionality: The more serious the bug, the greater the impact it will have on the functionality of the application. A bug that causes the application to crash or prevents a key feature from working would be considered more severe than a cosmetic issue.

2. Impact on users: Consider the impact the bug will have on the users of the application. A bug that causes significant inconvenience or frustration for users would be considered more severe than a bug that has minimal impact on the user experience.

3. Reproducibility: The more easily a bug can be reproduced, the more severe it is likely to be. A bug that occurs consistently and is easy to reproduce would be considered more severe than a bug that is difficult to reproduce or occurs only occasionally.

4. Workaround availability: If there is a workaround available for the bug, it may be less severe than a bug for which there is no workaround.

By considering these factors, you can determine the severity of a bug and prioritize it accordingly. Keep in mind that the severity of a bug may change over time, so it's important to regularly review and re-evaluate the severity of each bug.

Key Considerations for Reporting Bugs

Here are some key points to consider when reporting a bug

1. Describe the problem clearly: Be as specific as possible when describing the issue. Include details such as the steps that led to the bug, any error messages that were displayed, and the expected behavior versus the actual behavior.

2. Provide reproduction steps: If possible, provide a step-by-step guide for reproducing the bug. This will help the development team understand the issue and make it easier for them to fix it.

3.Include relevant information: Include information such as the device, operating system, and browser that you were using when the bug occurred. This will help the development team narrow down the cause of the issue.

4. Attach screenshots or video: If possible, attach screenshots or a video of the bug. This will give the development team a visual reference and may help them understand the issue better.

5. Assign a severity level: Assign a severity level to the bug based on its impact on the application and its users. This will help the development team prioritize their work and determine how urgently the bug needs to be addressed.

By following these guidelines, you can help the development team understand the issue and fix the bug more efficiently.

Documenting and Tracking Bugs

There are several ways to document bugs effectively:

1. Use a bug tracking tool: A bug tracking tool is a software application that is specifically designed to help teams manage and track bugs in a software development project. These tools typically allow you to create a bug report, assign it to a team member, and track its progress until it is resolved. Some popular bug tracking tools include JIRA, Bugzilla, and Trello.

2. Use a spreadsheet: A spreadsheet is a simple and effective way to document and track bugs. You can create a spreadsheet with columns for the bug description, severity, status, and other relevant information. This can be shared with the development team and updated as the bug is addressed.

3. Use a project management tool: A project management tool is another option for tracking bugs. These tools allow you to create tasks, assign them to team members, and track progress. You can use a project management tool to document bugs and track their progress until they are resolved. Some popular project management tools include Asana and Trello.

Regardless of the method you choose, it's important to include as much detail as possible in the bug report. This will help the development team understand the issue and make it easier for them to fix the bug.

Bug Severity and Handling Strategies

Here is a general strategy for handling bugs in a software application

1. Low: These bugs may be cosmetic or have minimal impact on the functionality of the application, but they should still be documented and scheduled for a future fix.

2. Minor These bugs may cause some inconvenience or minor functionality issues, but they do not severely impact the use of the application. They should be prioritized and fixed as soon as possible, but they may not need to be addressed immediately if there are more pressing issues.

3. Major: These bugs have a significant impact on the functionality of the application and should be addressed as soon as possible. They may require immediate attention, depending on the severity of the issue.

5. Critical: These bugs are severe and need to be fixed immediately. They may cause the application to fail or cause significant inconvenience for users.

When addressing bugs, it's important to prioritize based on the severity of the issue and the impact it has on the application and its users. It's also important to properly document and track bugs so that they can be effectively managed and resolved.

Good v/s Bad bug

Bugs can be both good and bad, depending on the context.

On the one hand, bugs can be good because they can help identify problems in the code and improve the overall quality of the software. By identifying and fixing bugs, developers can improve the reliability and stability of the software, ensuring that it functions as intended.

On the other hand, bugs can be bad because they can cause problems for users and disrupt the functioning of the software. If a bug is severe or impacts a key feature of the software, it can cause significant inconvenience or frustration for users.

Ultimately, the "goodness" or "badness" of a bug depends on the context in which it occurs and how it is addressed. By identifying and fixing bugs, developers can ensure that the software is as stable and reliable as possible, which is generally a good thing for users.

Process for Fixing Bugs

Here is a general process for fixing bugs in software development:

1. Identify the bug: The first step in fixing a bug is to identify that it exists. This may involve receiving a report from a user or discovering the bug during testing.

2. Reproduce the bug: In order to fix a bug, it is important to be able to reproduce it consistently. This may involve following a set of reproduction steps provided by the user or trying different scenarios to see when the bug occurs.

3. Debug the code: Once the bug has been identified and reproduced, the developer can begin the process of debugging the code. This may involve adding print statements or using a debugger to identify the root cause of the problem.

4. Determine the root cause: Once the developer has a better understanding of the problem, they can determine the root cause of the bug. This may involve identifying a specific line of code that is causing the issue or identifying a problem with the logic of the code.

5. Develop a fix: Once the root cause of the bug has been identified, the developer can develop a fix for the problem. This may involve writing new code, refactoring existing code, or updating external dependencies.

6. Test the fix: Before deploying the fix, it is important to test it to ensure that it addresses the issue and does not introduce any new problems. This may involve writing additional test cases or using automated testing tools.

7. Deploy the fix: Once the fix has been thoroughly tested and is deemed stable, it can be deployed to the live application. This may involve releasing a new version of the software or pushing the fix to the live application through a patch or update.

By following this process, developers can effectively troubleshoot and fix bugs in their code, improving the overall stability and reliability of the software.

Summary

To summarize, here are the key points to consider when handling bugs in a software application:

Bugs are an inevitable part of the software development process. They can have both positive and negative impacts on the software, depending on how they are managed. To effectively handle bugs, it is important to prioritize them based on their severity and properly document and track them. There are several types of bugs that can occur, including syntax errors, logic errors, run-time errors, resource leaks, and security vulnerabilities.
To fix a bug, developers must identify and reproduce the problem, debug the code to determine the root cause, develop a fix, test the fix, and deploy it to the live application. By following this process, developers can effectively troubleshoot and fix bugs, improving the stability and reliability of the software

Pulse - Project Management app built in ReactJS

Sonu Sharma 💙 — Wed, 25 Jan 2023 04:46:52 +0000

Introducing Pulse - the project/doc management app that will change the way you work!

Built with React on the front end and Node.js on the backend, Pulse is designed to help you easily track the progress of your projects and tasks. Whether you're working on a small personal project or a large enterprise project, Pulse is the tool you need to stay organized and on track.

With Pulse, you'll be able to quickly add and update your projects and tasks, view their status and progress. The intuitive interface makes it easy to use, so you can focus on what's important - achieving your goals.

Screenshots:

More screenshot here

If you're looking for a better way to manage your projects, give Pulse a try. It's open-source and the source code is available on Github, feel free to check it out and let us know what you think.

Check live version : https://go.orgnise.in/home

Source code : https://git.new/orgnise

Flutter Filter list package v1.0.0 released on pub.dev 🎉

Sonu Sharma 💙 — Fri, 21 May 2021 09:21:19 +0000

filterList is a flutter package which provide utility to search/filter data from provided dynamic list.

Change Logs

[1.0.0] 21 May 2021

Improved visual customization. Including remove custom function.
Added below arguments to improve the customization and make it translatable.
- allButtonText
- applyButtonText
- resetButtonText
- selectedItemsText
Added buttonRadius button border radius argument.
Added controlContainerDecoration action buttons box decoration argument.
Added buttonSpacing button spacing argument.
Added validateRemoveItem custom remove function that returns the selected list items filtered by the user conditions.
Added insetPadding dialog padding argument.
Added wrapAlignment argument to control the choice chips alignment in main axis.
Added wrapCrossAxisAlignment argument to control choice chip within a run should be aligned relative to each other in the cross axis.
Added wrapSpacing argument to control the space to place between choice chip in a run in the main axis.

Package link:- Pub.dev

Demo App link:- Demo App

Source code:- Github Repo

Contributing

If you wish to contribute a change to any of the existing features or add new in this repo,
please review our contribution guide,
and send a pull request. I welcome and encourage all pull requests. It usually will take me within 24-48 hours to respond to any issue or request.

Flutter Filter list package v.0.06, v.0.07, v.0.08 and v.0.09

Sonu Sharma 💙 — Mon, 17 May 2021 13:57:03 +0000

filterList is a flutter package which provide utility to search/filter data from provided dynamic list.

Change Logs

[0.0.9] - 01 Apr 2021

Migrated to null safety.
label is replaced with choiceChipLabel

[0.0.8] - 28 Mar 2021

Added choiceChipBuilder to build custom choice chip.
Added selectedChipTextStyle, unselectedChipTextStyle, controlButtonTextStyle, applyButtonTextStyle, headerTextStyle and searchFieldTextStyle styles.
Removed applyButonTextColor, allResetButonColor, selectedTextColor, unselectedTextColor colors properties.

[0.0.7] - 20 Feb 2021

Update Doc

[0.0.6] - 20 Feb 2021

Convert filter list package to generic list filter package
allTextList changed to listData
selectedTextList changed to selectedListData
FilterListWidget and FilterListDialog can filter any type if list
Added validateSelectedItem callback to validate which item needs to be selected
Added onItemSearch callback to expose search mechanism on user side to filter list.'

Package link:- https://pub.dev/packages/filter_list

Demo App link:- Demo App

Source code:- https://github.com/TheAlphamerc/flutter_plugin_filter_list

Contributing

GitConnect - A Github application built in flutter

Sonu Sharma 💙 — Tue, 20 Oct 2020 11:10:19 +0000

Introduction

Hey folks, For the past few months I have been working on an opensource flutter project.GitConnect is a github mobile app created in Flutter. The first version of the app is released on play store. As of now, the functionality of the app is quite simple. You can browse your recent activities, repositories, read their ‘readme’ files, view pull requests, issues, forks, stargazers, and commits.

The notifications and search features are also integrated, making it easier to browse the repositories and/or developers. GitConnect also has a dark theme. You can turn it on manually in the settings. By default, the application’s theme is a dark theme.

Functionalities

Below is a list of functionalities included in-app.

Login with Github account
See your public, private, and forked Repos
See repo stargazers and fork Repos
Activities
Notifications
Repositories
Add to favorite
Gists
Commits
Following/Followers
View Gists and their files
View users profile, contribution graph, activities, repositories, pull request, and issues
Markdown and code highlighting support
Search Users, Repos, Issues, Pull Requests, and Code
Dual theme (Dark/Light)

App Architecture

Application uses BloC architecture to manage app states. In order to implement BloC I use flutter_bloc package created by Felix Angelov. Using the bloc library allows us to separate our application into three layers:

Presentation
Business Logic
Data
- Repository
- Data Provider

Here’s the overview of our project structure: In the lib folder, I have created the following folders:

The UI folder has all the code for the app ui. It has 3 subfolders.
- page : This folder has app screens.
- theme: This folder has app-text styles,color codes, and themes.
- widget: This folder consists global generic widget used in app.
The resources folder contains 5 subfolders
- Gatway: The gatway folder contains classes to make external calls, like calls to get user profiles, repositories list etc. These classes don’t care about the UI or how the UI wants to display the data. They can throw an exception when something goes wrong.
- Service: This folder contains classes that are used to taken care of session management and local database.
- Repository: This folder contains various repositories classes to pass data from API gateway to blocs and vice versa.
GraphqlApi: This folder contains Github graphql queries.
The Helper folder contains classes that convert the raw data from Services to the form that is useful in our app.
Exceptions: This class gracefully handles exceptions that can occur in API call and convert them to messages which will be helpful to pass to blocs and display the message on screen if necessary.
The model folder contains model classes.
The bloc folder contains multiple blocs that hold almost the business logic of app to connect the UI and application logic.

Package used

App Preview

Links

App link:- Play Store

Project source code link :- Github

If you found a bug or want to suggest a feature report it here:- Issues

Contributing

Project Created & Maintained By

Sonu Sharma (Twitter) (Youtube) (Insta)

I would love to hear from you. Please share your valuable feedback in the comments.
If you like the project do show love by giving star the repo.

Flutter filter list package v.0.05 released on pub.dev

Sonu Sharma 💙 — Tue, 22 Sep 2020 10:15:52 +0000

FilterList is a flutter plugin that is designed to provide ease in filter data from a list of strings.

Changelogs

Add FilterListWidget widget.
FilterList.showFilterList is renamed to FilterListDialog.display
Add onApplyButtonClick callback to return selected text list from FilterListDialog.display.

Package link:- https://pub.dev/packages/filter_list

Demo App link:- https://github.com/TheAlphamerc/flutter_plugin_filter_list/releases/download/v0.0.5/app-release.apk

Source code:- https://github.com/TheAlphamerc/flutter_plugin_filter_list

Data flow

Pass list of strings to FilterListDialog.display().
Pass list of selected strings to show pre-selected text otherwise ignore it.
Invoke method FilterListDialog.display to display filter dialog.
Make selection from list.
Click All button to select all text from the list.
Click Reset button to make all text unselected.
Click Apply button to return selected list of strings.
On close icon clicked it close dialog and return a null value.
Without making any selection Apply button is pressed it will return an empty list of string.

Getting Started

1. Add library to your pubspec.yaml

dependencies:
  filter_list: ^0.0.5

2. Import library in dart file

import package:filter_list/filter_list.dart';

3. How to use FilterList

Create a list of Strings

  List<String> countList = [
    "One",
    "Two",
    "Three",
    "Four",
    "Five",
    "Six",
    "Seven",
    "Eight",
    "Nine",
    "Ten",
    "Eleven",
    "Tweleve",
    "Thirteen",
    "Fourteen",
    "Fifteen",
    "Sixteen",
    "Seventeen",
    "Eighteen",
    "Nineteen",
    "Twenty"
  ];
  List<String> selectedCountList = [];

Create a function and call `FilterListDialog.display()` on button clicked

  void _openFilterDialog() async {
    await FilterListDialog.display(
      context,
      allTextList: countList,
      height: 480,
      borderRadius: 20,
      headlineText: "Select Count",
      searchFieldHintText: "Search Here",
      selectedTextList: selectedCountList,
      onApplyButtonClick: (list) {
        if (list != null) {
          setState(() {
            selectedCountList = List.from(list);
          });
        }
        Navigator.pop(context);
      });
  }

Call `_openFilterDialog` function on `floatingActionButton` pressed to display filter dialog

  @override
  Widget build(BuildContext context) {
    return Scaffold(
        appBar: AppBar(
          title: Text(widget.title),
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: _openFilterDialog,
          tooltip: 'Increment',
          child: Icon(Icons.add),
        ),
        /// check for empty or null value selctedCountList
        body: selectedCountList == null || selectedCountList.length == 0
            ? Center(
                child: Text('No text selected'),
              )
            : ListView.separated(
                itemBuilder: (context, index) {
                  return ListTile(
                    title: Text(selectedCountList[index]),
                  );
                },
                separatorBuilder: (context, index) => Divider(),
                itemCount: selectedCountList.length));
  }

To display filter widget use `FilterListWidget` and pass list of strings to it.

class FilterPage extends StatelessWidget {
  const FilterPage({Key key, this.allTextList}) : super(key: key);
  final List<String> allTextList;
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Filter list Page"),
      ),
      body: SafeArea(
        child: FilterListWidget(
          allTextList: allTextList,
          height: MediaQuery.of(context).size.height,
          hideheaderText: true,
          onApplyButtonClick: (list) {
            if(list != null){
              print("selected list length: ${list.length}");
            }
          },
        ),
      ),
    );
  }
}

Screenshots

No selected text from list	FilterList widget	Make selection	Selected text from list

Hidden close Icon	Hidden text field	Hidden header text	Hidden full header

Customised control button	Customised selected text	Customised unselected text	Customised text field background color

FilterListWidget	N/A	N/A	N/A

Parameters and Value

height Type: double

Set height of filter dialog.

width Type: double

Set width of filter dialog.

borderRadius Type: double

Set border radius of filter dialog.

allTextList Type: List<String>()

Populate filter dialog with text list.

selectedTextList Type: List<String>()

Marked selected text in filter dialog.

headlineText Type: String

Set header text of filter dialog.

searchFieldHintText Type: String

Set hint text in search field.

hideSelectedTextCount Type: bool

Hide selected text count.

hideSearchField Type: bool

Hide search text field.

hidecloseIcon Type: bool

Hide close Icon.

hideheader Type: bool

Hide complete header section from filter dialog.

closeIconColor Type: Color

set color of close Icon.

headerTextColor Type: Color

Set color of header text.

applyButonTextColor Type: Color

Set text color of apply button.

applyButonTextBackgroundColor Type: Color

Set background color of apply button.

allResetButonColor Type: Color

Set text color of all and reset button.

selectedTextColor Type: Color

Set color of selected text in filter dialog.

selectedTextBackgroundColor Type: Color

Set background color of selected text field.

unselectedTextbackGroundColor Type: Color

Set background color of unselected text field.

unselectedTextColor Type: Color

Set text color of unselected text in filter dialog

searchFieldBackgroundColor Type: Color

Set background color of Search field.

backgroundColor Type: Color

Set background color of filter color.

onApplyButtonClick Type Function(List)

Returns list of strings when apply button is clicked

Contributing

Project Created & Maintained By

Sonu Sharma (Twitter) (Youtube) (Insta)

Fwitter android app v1.0.6 is released on play store

Sonu Sharma 💙 — Sat, 18 Jul 2020 03:43:58 +0000

A Fwitter is a working Twitter clone written in Flutter using firebase features like auth, realtime database and storage.

New feature

Tweet filter functionality added on profile page.
User profile pic view added to view user profile picture.
User can tag other users in tweet, comment and in retweet.
A notification will send to you if someone tag you in a tweet.
If user tap on notification from system notification tray, it will redirect to user profile who tagged you.
Chat list sorted by last message.
Last message and time is added on chat user list page.

App link:- https://play.google.com/store/apps/details?id=com.thealphamerc.flutter_twitter_clone

Source code:- https://github.com/TheAlphamerc/flutter_twitter_clone

Work progress status:- https://github.com/TheAlphamerc/flutter_twitter_clone/projects

Contributing

Project Created & Maintained By

Sonu Sharma (Twitter) (Youtube) (Insta)

Spacexopedia | Built with Flutter

Sonu Sharma 💙 — Sat, 11 Jul 2020 04:16:58 +0000

Introduction

Hello guys, From the past 4 weeks I was working on a flutter project not dedicatedly but in my free time. The purpose of this project is to develop the ultimate SpaceX experience in a variety of platforms. A single experience, from a single codebase.

About Spacexopedia

Spacexopedia has been developed to provide information about space projects of giant space company SpaceX. App is a light-weight, fast and easy to use. It fetches the data from the open-source r/SpaceX REST API, which can be found here.

This Spacexopedia has been built using the Flutter framework, which allows to build an app for mobile, desktop & web, from a single codebase.

App features:-

Past & upcoming launches: flight no., launch date, location, vehicle type,rocket used etc.
Tesla Roadster : orbit, speed & distance of the Elon Musk's Tesla Roadster.
Rockets catalog: read about all rockets, capsules & ships SpaceX has developed over the years.
Dragon capsule catalog: type, diameter, height, weight, capacity, payload.
Core & capsules details: more information about each core & capsules launched

After the completion of the first phase, it seemed to be in a stable state so I have decided to publish it on the play store.

Wrapping it up

This application is not affiliated with, funded or in any other way associated with SpaceX company.

If this project inspires you to build anything interesting let me know in comments. If you have any ideas for new features or wants to contribute in project be sure to send a pull request.
If you found a bug or want to suggest a feature report it here. If you like the project then show your love by giving star the repo.