Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/redinfinitypro/improve_my_github


https://github.com/redinfinitypro/improve_my_github

Last synced: 3 months ago
JSON representation

Awesome Lists containing this project

README 

        
# Improve_My_GitHub



# Table of Contents



- [News](#news)

- [GitHub](#github)

- [Style Guide](#style_guide)



# News: 

- Currently, adding images to the README files for some projects

        

# GitHub



Add a README:

* Ensure each repository has a clear and informative README file to help users understand the project.



Branch Management:

* Practice using branches effectively for feature development, bug fixes, and experimentation.



Contributor Guidelines:

* Provide guidelines for contributors, including how to submit issues, make changes, and contribute code.



Documentation:

* Keep your codebase well-documented with inline comments and external documentation files.



Engage with the Community:

* Respond promptly to issues, pull requests, and comments to engage with contributors and users.



Frequent Commits:

* Make frequent, small commits with clear commit messages to track changes effectively.



GitHub Pages:

* Use GitHub Pages to host project documentation, demos, or websites related to your projects.



Host Documentation:

* Utilize GitHub Pages or other hosting services to host comprehensive documentation for your projects. Having well-maintained documentation makes it easier for users and contributors to understand your project and its features, leading to better adoption and collaboration.



Issue Triage:

* Regularly triage and manage open issues to keep track of bugs, feature requests, and enhancements.



Join Open Source Projects:

* Contribute to open-source projects to gain experience and build your reputation within the community.



Keep Projects Updated:

* Keep your repositories updated with the latest changes, fixes, and improvements.



License:

* Choose an appropriate open-source license for your projects to clarify how others can use and contribute to your code.



Maintain a Changelog:

* Maintain a changelog to document notable changes in each release of your project.



Network with Developers:

* Follow and interact with other developers and projects to build a network and learn from others.



Open Source Contributions:

* Contribute to other open-source projects to gain experience, improve your skills, and give back to the community.



Project Boards:

* Use project boards to organize and track tasks, issues, and progress within your repositories.



Quality Assurance:

* Implement automated testing, code reviews, and quality checks to ensure the reliability and stability of your code.



Release Management: 

* Manage releases effectively, including tagging versions, updating release notes, and providing changelogs.



Squash Commits: 

* Consider squashing multiple small commits into larger, more meaningful commits before merging into the main branch.



Testing Automation: 

* Automate testing processes to ensure code changes are thoroughly tested before merging into the main branch.



Update Dependencies: 

* Regularly update dependencies to keep your project's dependencies secure and up-to-date.



Version Control: 

* Familiarize yourself with version control concepts and best practices, such as branching, merging, and resolving conflicts.



Work in Progress (WIP) Tags: 

* Use WIP tags or draft pull requests to indicate work in progress and seek feedback before finalizing changes.



eXamine Code Review Feedback: 

* Take the time to thoroughly review and address feedback from code reviews to improve code quality and collaboration.



YAML Configuration: 

* Utilize YAML configuration files for settings, workflows, and other project configurations to maintain consistency and readability.



Zero Tolerance for Code Smells:

* Strive to maintain a codebase with minimal code smells by regularly refactoring and improving code quality.



# Style_Guide



## CSS (CSS Coding Style Guide)



Box Model: 

  * A fundamental concept in CSS that describes the layout of elements on a web page. It consists of the content area, padding, border, and margin of an element.



Cascading:

  * The process by which multiple style rules are applied to an element, and conflicts are resolved based on specificity, importance, and source order.



Class Selector: 

  * A CSS selector that targets elements with a specific class attribute. It is denoted by a period (.) followed by the class name in the CSS rule.



Comments: 

  * Text in a CSS file that is not rendered by the browser and is used for documentation or to provide context for the code. Comments in CSS are denoted by /* */.



Flexbox: 

  * A layout model in CSS that allows for the creation of flexible and responsive layouts. It provides a more efficient way to align and distribute space among elements in a container.



Grid Layout: 

  * A layout model in CSS that allows for the creation of complex grid-based layouts. It enables precise control over the placement and alignment of elements within a grid container.



ID Selector: 

  * A CSS selector that targets a specific element with a unique ID attribute. It is denoted by a hash (#) followed by the ID name in the CSS rule.



Media Queries: 

  * Conditional statements in CSS that allow for the application of styles based on various device characteristics, such as screen size, resolution, and orientation. Media queries are commonly used for creating responsive designs.



Normalize CSS: 

  * A CSS reset or normalization stylesheet that aims to make browser styles consistent across different browsers by resetting or normalizing default styles.



Pseudo-class: 

  * A keyword added to a selector that specifies a special state of the selected element. Common pseudo-classes include :hover, :active, :focus, and :first-child.



Pseudo-element: 

  * A keyword added to a selector that specifies a specific part of the selected element. Common pseudo-elements include ::before, ::after, ::first-line, and ::first-letter.



Selector: 

  * A pattern used to select and style one or more elements in a document. Selectors can target elements based on their type, class, ID, attributes, or relationships with other elements.



Specificity: 

  * A measure of how specific a CSS rule is in targeting elements. Specificity determines which style rule takes precedence when multiple rules conflict.



Units: 

  * The measurement units used to define lengths, sizes, and positions in CSS. Common units include pixels (px), percentages (%), ems (em), and rems (rem).



Vendor Prefixes: 

  * Prefixes added to CSS properties to ensure compatibility with specific browsers or browser versions. Vendor prefixes are used for experimental or non-standard properties and are gradually phased out as standards are adopted.



## C# (C# Coding Conventions)



Access Modifiers: 

 * Keywords used to specify the accessibility of types and members in C#. Common access modifiers include public, private, protected, and internal.



Async/Await: 

 * Keywords used in C# to implement asynchronous programming. async is used to define methods that can execute asynchronously, while await is used to asynchronously wait for the result of an asynchronous operation.



Casing: 

 * The convention used for naming identifiers such as variables, methods, and classes in C#. Common casing styles include camelCase, PascalCase, and snake_case.



Comments: 

 * Text added to source code to provide explanations, documentation, or annotations. Comments in C# can be single-line (//) or multi-line (/* */), and they are ignored by the compiler.



Constants: 

 * Variables whose values cannot be changed once they are assigned. Constants in C# are declared using the const keyword and must be initialized at the time of declaration.



Delegates: 

 * A type that represents references to methods with a specific signature. Delegates in C# allow methods to be passed as parameters and stored as variables, enabling powerful callback mechanisms and event handling.



Exceptions: 

 * Anomalies or errors that occur during the execution of a program. Exception handling in C# involves using try, catch, finally, and throw keywords to handle and manage exceptions gracefully.



LINQ (Language Integrated Query): 

 * A feature in C# that allows for querying collections and other data sources using a SQL-like syntax directly within the language. LINQ provides a powerful and expressive way to manipulate data in C#.



Namespaces: 

 * Containers used to organize and group related classes, interfaces, and other types in C#. Namespaces help in avoiding naming conflicts and organizing code into logical units.



Nullability: 

 * The ability for a variable or expression to represent the absence of a value (null). Nullability in C# can be indicated using nullable value types (Nullable) or the null-conditional operator (?.).



Properties: 

 * Members of a class that encapsulate fields and provide controlled access to their values. Properties in C# are typically defined using get and set accessors and provide a way to enforce encapsulation and data validation.



Regions: 

 * Blocks of code in C# that can be collapsed or expanded in the code editor. Regions are often used to group related code sections and improve code organization and readability.



Using Directives: 

 * Statements that import namespaces into a C# file, allowing types from those namespaces to be used without fully qualifying their names. Using directives help in simplifying code and reducing verbosity.



## HTML (HTML Coding Style Guide)



Attribute Ordering: 

 * Guidelines for arranging HTML attributes within HTML tags in a consistent and logical order. Attribute ordering improves readability and maintainability of HTML code.



Class Names: 

 * Naming conventions for HTML class attributes used to apply CSS styles or JavaScript behaviors to HTML elements. Consistent class naming conventions help in organizing and styling HTML content effectively.



Comments: 

 * Guidelines for adding comments within HTML code to provide explanations, documentation, or reminders for developers. Comments in HTML should be concise, clear, and focused on explaining the purpose or intent of the code.



Doctype Declaration: 

 * A statement at the beginning of an HTML document that declares the HTML version being used and triggers standards mode rendering in web browsers. The doctype declaration ensures compatibility and consistent rendering across different browsers.



Element Naming: 

 * Naming conventions for HTML element tags to ensure clarity and consistency in markup structure. Descriptive and semantic element names improve code readability and maintainability.



Indentation: 

 * Guidelines for indenting HTML code to visually represent the hierarchical structure of the document. Consistent indentation enhances code readability and makes it easier to understand the document's structure.



Quotation Marks: 

 * Rules for choosing between single (') and double (") quotation marks when specifying attribute values in HTML. Consistent use of quotation marks improves code consistency and readability.



Self-Closing Tags: 

 * Guidelines for using self-closing tags in HTML for elements that do not have closing tags, such as  and 
. Self-closing tags should be used consistently to maintain code clarity and compatibility.



Tag Lowercasing: 

 * Recommendations for using lowercase letters in HTML element tags to ensure consistency and compatibility with XHTML and XML standards. Using lowercase tags improves code readability and maintainability.



Whitespace: 

 * Guidelines for using whitespace (spaces, tabs, line breaks) within HTML code to improve readability and organization. Consistent whitespace usage enhances code clarity and makes it easier to understand the document's structure.



## Java (The Java Language Specification)



Abstract Method: 

  * A method declared without an implementation in an abstract class or interface, which must be implemented by subclasses or implementing classes.



Access Control: 

  * The mechanism by which access to classes, interfaces, fields, and methods is regulated in Java, using access modifiers like public, protected, default (package-private), and private.



Annotation:

  * A form of metadata that provides data about a program but is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate.



Array: 

  * A data structure that stores a fixed-size sequential collection of elements of the same type. In Java, arrays are objects, and they can be declared and initialized using square brackets [].



Assignment: 

  * The process of storing a value in a variable. In Java, assignment is performed using the assignment operator =.



Block:

  * A sequence of statements enclosed in braces {}. Blocks are used to group statements together and define scope in Java.



Class:

  * A blueprint for creating objects that define the properties and behaviors of objects. Classes in Java can have fields, methods, constructors, and nested classes.



Compilation Unit:

  * A source code file containing a Java program or a portion thereof, which can be compiled independently. Each compilation unit can contain one or more classes or interfaces.



Expression: 

  * A combination of variables, operators, and method calls that evaluates to a single value. Expressions can be used in assignments, method calls, and control flow statements.



Field: 

  * A variable declared within a class that represents the state of an object. Fields are also known as instance variables or member variables.



Interface: 

  * A reference type in Java that defines a set of abstract methods and constants. Interfaces cannot be instantiated but can be implemented by classes to provide concrete implementations of the abstract methods.



Method: 

  * A block of code that performs a specific task and may return a value. Methods are declared within classes and can be invoked to perform their defined functionality.



Package: 

  * A namespace that organizes a set of related classes and interfaces. Packages help in preventing naming conflicts and provide a modular structure for organizing code.



Statement: 

  * A complete unit of execution that performs a specific action. Statements in Java can include variable declarations, assignments, control flow constructs, method calls, and other expressions.



Type: 

  * A classification of data that specifies the possible values it can hold and the operations that can be performed on it. Types in Java include primitive types (e.g., int, double, boolean) and reference types (e.g., classes, interfaces, arrays).



Variable: 

  * A named storage location in memory that holds a value. Variables in Java can be declared with a specific type and may be assigned new values during program execution.



## JavaScript (JavaScript Standard Style.)



Arrow Functions: 

  * A concise way to write function expressions in JavaScript using the arrow (=>) syntax. Arrow functions are often used for inline function expressions and have a more concise syntax compared to traditional function expressions.



Camel Case: 

  * A naming convention in which multiple words are joined together with no spaces, and each word's initial letter except the first is capitalized. Camel case is commonly used for naming variables, functions, and object properties in JavaScript.



Callback Function: A

  * function passed as an argument to another function, which is then invoked inside the outer function to perform some action. Callback functions are commonly used in asynchronous programming and event handling in JavaScript.



Closure: 

  * A function that captures and retains references to variables from its lexical scope, even after the outer function has finished executing. Closures allow for maintaining state and creating private variables in JavaScript.



Constructor Function: 

  * A function used to create and initialize objects with a specific structure and behavior. Constructor functions are typically invoked with the new keyword and are used to define custom object types in JavaScript.



Event Listener: 

  * A function that listens for a specific event to occur and executes a callback function when that event occurs. Event listeners are commonly used to handle user interactions and respond to changes in the browser environment.



Hoisting: 

  * A JavaScript behavior where variable and function declarations are moved to the top of their containing scope during the compilation phase. This allows variables and functions to be used before they are declared.



Module: 

  * A self-contained unit of code that encapsulates related functionality and can be reused across different parts of a JavaScript application. Modules help in organizing code, managing dependencies, and promoting code reusability.



Promise: 

  * An object representing the eventual completion or failure of an asynchronous operation in JavaScript. Promises simplify asynchronous programming by providing a more structured way to handle asynchronous tasks and their results.



Strict Mode: 

  * A JavaScript feature that enables a stricter set of rules for parsing and executing code. Strict mode helps in identifying and fixing common programming errors by enforcing better coding practices and preventing certain unsafe actions.



Template Literal: 

  * A string literal allowing embedded expressions, which are enclosed in ${}. Template literals provide a more concise and readable way to create strings with dynamic content compared to traditional string concatenation.



Type Coercion: 

  * A JavaScript feature where values of different types are automatically converted to a common type during operations. Understanding type coercion is important for avoiding unexpected behavior and writing robust JavaScript code.



Variable Declaration: 

  * The process of declaring a variable to reserve memory space and specify its name and type. Variable declarations in JavaScript can use keywords like var, let, and const to define variables with different scoping and mutability characteristics.



Whitespace: 

  * Spaces, tabs, and line breaks in code that are used for formatting and readability purposes. Consistent whitespace usage is important for maintaining code readability and adhering to a consistent coding style.



## Python (PEP 8)



lank Lines

  * Use blank lines sparingly to separate sections of code for readability.

  * Surround top-level function and class definitions with two blank lines.

  * Method definitions inside a class are surrounded by a single blank line.



Coding Recommendations

  * Follow Python's naming conventions.

  * Use is and is not for comparison to None.

  * Use isinstance() to compare types.



Comments

  * Use inline comments sparingly.

  * Comments should be complete sentences.

  * Use docstrings for all public modules, functions, classes, and methods.



Documentation Strings (Docstrings)

  * Write docstrings for all public modules, functions, classes, and methods.

  * Docstrings should be surrounded by triple double quotes """.



Imports

  * Imports should usually be on separate lines.

  * Imports should be grouped in the following order:

      - Standard library imports.

      - Related third-party imports.

      - Local application/library specific imports.

  * Each group should be separated by a blank line.

  * Use a separate line for each import statement.

  * Use a blank line between the standard library imports and third-party imports.

  * Use a blank line between third-party imports and local application/library-specific imports.



Imports Formatting

  * Use a separate line for each import statement.

  * Use a blank line between the standard library imports and third-party imports.

  * Use a blank line between third-party imports and local application/library-specific imports.



Indentation

  * Use 4 spaces per indentation level.

  * Continuation lines should align wrapped elements vertically.



Maximum Line Length

  * Limit all lines to a maximum of 79 characters.

  * For comments or docstrings, limit lines to 72 characters.



Naming Conventions

  * Use ALL_CAPS for constants.

  * Use CamelCase for class names.

  * Use lowercase_with_underscores for function and variable names.

  * Use lowercase_with_underscores for module names.

  * Avoid single-letter variables except for counters or iterators.



String Quotes

  * Use single quotes ' for string literals unless the string contains a single quote character.



Tabs or Spaces

  * Use spaces, not tabs, for indentation.



Whitespace Around Keywords and Parameter Assignments

  * Avoid extraneous whitespace around the following:

      - Keywords (if, while, for, with, try, except, finally, etc.).

      - Parameter equals sign in a function definition.

        

Whitespace in Expressions and Statements

  * Avoid extraneous whitespace in the following situations:

      - Immediately inside parentheses, brackets, or braces.

      - Between a trailing comma and a following close parenthesis.

      - Avoid multiple statements on the same line.

  * Always surround these binary operators with a single space on either side: assignment (=), augmented assignment (+=, -=, etc.), comparisons (==, <, >, !=, <>, <=, >=, in, not in, is, is not), Booleans (and, or, not).

    

## SQL (SQL Style Guide)



Aliases

 * Short names assigned to tables or columns in SQL queries for brevity and readability. Aliases can be used to simplify complex queries and improve code clarity by providing shorthand references to database objects.



Case Sensitivity: 

 * The property of a database system to differentiate between uppercase and lowercase letters in SQL identifiers and string comparisons. Understanding the case sensitivity rules of a database system is important for writing accurate SQL queries.



Comments: 

 * Explanatory notes added to SQL code to provide context, document assumptions, and clarify the purpose of queries or database structures. Comments help developers understand and maintain SQL code more effectively.



Data Types: 

 * The classification of data values in SQL based on their characteristics and storage requirements. SQL data types specify the kind of data that can be stored in a column of a table and define the operations that can be performed on that data.



Indentation: 

 * The practice of formatting SQL code with consistent and structured indentation to improve readability and maintainability. Indentation helps distinguish different parts of SQL queries and makes the code easier to follow.



Join Syntax: 

 * The syntax used to perform joins between tables in SQL queries. SQL supports different types of joins such as inner joins, outer joins, and cross joins, each with its own syntax for specifying the join condition.



Naming Conventions: 

 * Guidelines for naming database objects such as tables, columns, indexes, and constraints in SQL databases. Consistent naming conventions help developers understand the purpose and structure of database objects and facilitate collaboration in team environments.



Query Structure: 

 * The organization and layout of SQL queries, including the arrangement of clauses such as SELECT, FROM, WHERE, GROUP BY, HAVING, and ORDER BY. Following a consistent query structure improves code readability and comprehension.



Quotes: 

 * The characters used to delimit string literals and identifiers in SQL queries. SQL supports different types of quotes such as single quotes (') and double quotes (") for specifying strings and identifiers with spaces or special characters.



Semicolons: 

 * The punctuation mark used to terminate SQL statements and indicate the end of a query. While some database systems allow omitting semicolons in simple queries, it's a best practice to include them for clarity and consistency.



Spacing: 

 * The arrangement of spaces between keywords, operators, and clauses in SQL queries. Consistent spacing improves code readability and makes it easier to understand the logical structure of SQL statements.



Subqueries: 

 * Queries nested within other queries to perform more complex data retrieval and manipulation tasks. Subqueries can be used in SELECT, FROM, WHERE, and other clauses to filter, aggregate, or join data from multiple tables.



Table Aliases: 

 * Short names assigned to tables in SQL queries using the AS keyword. Table aliases are used to reference tables in multi-table queries and improve query readability by providing concise table identifiers.



Transaction Management: 

 * The process of ensuring the integrity and consistency of data in a database by grouping SQL statements into transactions and managing their execution. Proper transaction management is critical for maintaining data integrity in database applications.