Alternatives to ESLint logo

Alternatives to ESLint

TSLint, Prettier, JSLint, JSHint, and SonarQube are the most popular alternatives and competitors to ESLint.
30K
13.7K
+ 1
28

What is ESLint and what are its top alternatives?

ESLint is a popular static code analysis tool for identifying problematic patterns found in JavaScript code. It helps developers write cleaner and error-free code by enforcing coding standards and best practices. ESLint offers a wide range of rules and configurations to customize as per project requirements, along with support for various plugins. However, one limitation of ESLint is its steep learning curve for beginners, especially when dealing with configuring rules.

  1. Prettier: Prettier is an opinionated code formatter that ensures consistent formatting across a project. Key features include support for multiple languages, integration with popular editors, and automatic code formatting on save. Pros: Simplifies code formatting, reduces code review overhead. Cons: Limited customization options compared to ESLint.
  2. TSLint: TSLint is a static analysis tool for TypeScript that checks for coding errors and coding style issues. It offers a wide range of customizable rules, type checking, and integration with build tools. Pros: Designed specifically for TypeScript, extensive rule set. Cons: TSLint has been deprecated in favor of ESLint for TypeScript projects.
  3. JSHint: JSHint is a lightweight JavaScript code quality tool that helps developers catch errors and enforce coding conventions. Key features include customizable options, support for ES6 syntax, and easy integration with build tools. Pros: Simple to set up and use, good for beginners. Cons: Limited rule set compared to ESLint.
  4. StandardJS: StandardJS is a JavaScript style guide, linter, and formatter that aims to reduce the number of decisions developers need to make. It enforces a consistent coding style across the project without any configuration. Pros: Easy to set up, promotes consistent coding style. Cons: Lack of customization options compared to ESLint.
  5. Flow: Flow is a static type checker for JavaScript that helps catch errors early in the development process. It offers type inference, type checking, and error detection to improve code quality. Pros: Enhances code quality through type checking, seamless integration with JavaScript projects. Cons: Steeper learning curve for developers new to static typing.
  6. JSLint: JSLint is a JavaScript code quality tool that helps developers write cleaner and more maintainable code. It provides strict rules for coding style, error detection, and bug prevention. Pros: Straightforward setup, focuses on enforcing coding standards. Cons: Limited flexibility in rule customization.
  7. SonarQube: SonarQube is an open-source platform for continuous inspection of code quality. It offers static code analysis, code coverage, code duplication detection, and other features to improve code maintainability. Pros: Comprehensive code quality analysis, support for multiple languages. Cons: Setup and configuration can be complex for beginners.
  8. JSHint Next: JSHint Next is an evolution of the original JSHint tool with additional features and improvements. It provides error detection, coding style checks, and customizable options for JavaScript projects. Pros: Updated version of JSHint, improved performance. Cons: Limited community support compared to ESLint.
  9. Lintly: Lintly is a cloud-based code review tool that integrates with popular linters like ESLint, TSLint, and stylelint. It automates the code review process, provides actionable feedback, and helps maintain code quality standards. Pros: Seamless integration with existing linters, customizable rules. Cons: Limited support for other code quality tools.
  10. DeepScan: DeepScan is a code review tool that performs static code analysis for JavaScript projects. It offers advanced bug detection, performance optimization suggestions, security vulnerability checks, and more. Pros: Advanced code analysis capabilities, actionable insights for improving code quality. Cons: Limited to JavaScript projects only, may not be suitable for all codebases.

Top Alternatives to ESLint

  • TSLint
    TSLint

    An extensible static analysis tool that checks TypeScript code for readability, maintainability, and functionality errors. It is widely supported across modern editors & build systems and can be customized with your own lint rules, configurations, and formatters. ...

  • Prettier
    Prettier

    Prettier is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary. ...

  • JSLint
    JSLint

    It is a static code analysis tool used in software development for checking if JavaScript source code complies with coding rules. It is provided primarily as a browser-based web application accessible through their domain, but there are also command-line adaptations. ...

  • JSHint
    JSHint

    It is a community-driven tool to detect errors and potential problems in JavaScript code. It is open source and can easily adjust in the environment you expect your code to execute. ...

  • SonarQube
    SonarQube

    SonarQube provides an overview of the overall health of your source code and even more importantly, it highlights issues found on new code. With a Quality Gate set on your project, you will simply fix the Leak and start mechanically improving. ...

  • Babel
    Babel

    Babel will turn your ES6+ code into ES5 friendly code, so you can start using it right now without waiting for browser support. ...

  • SonarLint
    SonarLint

    It is an IDE extension that helps you detect and fix quality issues as you write code. Like a spell checker, it squiggles flaws so that they can be fixed before committing code. ...

  • Git
    Git

    Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. ...

ESLint alternatives & related posts

TSLint logo

TSLint

1.9K
0
An extensible linter for the TypeScript language
1.9K
0
PROS OF TSLINT
    Be the first to leave a pro
    CONS OF TSLINT
      Be the first to leave a con

      related TSLint posts

      Simon Reymann
      Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 11.2M views

      Our whole DevOps stack consists of the following tools:

      • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
      • Respectively Git as revision control system
      • SourceTree as Git GUI
      • Visual Studio Code as IDE
      • CircleCI for continuous integration (automatize development process)
      • Prettier / TSLint / ESLint as code linter
      • SonarQube as quality gate
      • Docker as container management (incl. Docker Compose for multi-container application management)
      • VirtualBox for operating system simulation tests
      • Kubernetes as cluster management for docker containers
      • Heroku for deploying in test environments
      • nginx as web server (preferably used as facade server in production environment)
      • SSLMate (using OpenSSL) for certificate management
      • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
      • PostgreSQL as preferred database system
      • Redis as preferred in-memory database/store (great for caching)

      The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

      • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
      • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
      • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
      • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
      • Scalability: All-in-one framework for distributed systems.
      • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
      See more
      Simon Reymann
      Senior Fullstack Developer at QUANTUSflow Software GmbH · | 24 upvotes · 4.9M views

      Our whole Vue.js frontend stack (incl. SSR) consists of the following tools:

      • Nuxt.js consisting of Vue CLI, Vue Router, vuex, Webpack and Sass (Bundler for HTML5, CSS 3), Babel (Transpiler for JavaScript),
      • Vue Styleguidist as our style guide and pool of developed Vue.js components
      • Vuetify as Material Component Framework (for fast app development)
      • TypeScript as programming language
      • Apollo / GraphQL (incl. GraphiQL) for data access layer (https://apollo.vuejs.org/)
      • ESLint, TSLint and Prettier for coding style and code analyzes
      • Jest as testing framework
      • Google Fonts and Font Awesome for typography and icon toolkit
      • NativeScript-Vue for mobile development

      The main reason we have chosen Vue.js over React and AngularJS is related to the following artifacts:

      • Empowered HTML. Vue.js has many similar approaches with Angular. This helps to optimize HTML blocks handling with the use of different components.
      • Detailed documentation. Vue.js has very good documentation which can fasten learning curve for developers.
      • Adaptability. It provides a rapid switching period from other frameworks. It has similarities with Angular and React in terms of design and architecture.
      • Awesome integration. Vue.js can be used for both building single-page applications and more difficult web interfaces of apps. Smaller interactive parts can be easily integrated into the existing infrastructure with no negative effect on the entire system.
      • Large scaling. Vue.js can help to develop pretty large reusable templates.
      • Tiny size. Vue.js weights around 20KB keeping its speed and flexibility. It allows reaching much better performance in comparison to other frameworks.
      See more
      Prettier logo

      Prettier

      7.7K
      7
      Prettier is an opinionated code formatter.
      7.7K
      7
      PROS OF PRETTIER
      • 2
        Customizable
      • 1
        Open Source
      • 1
        Atom/VSCode package
      • 1
        Follows the Ruby Style Guide by default
      • 1
        Runs offline
      • 1
        Completely free
      CONS OF PRETTIER
        Be the first to leave a con

        related Prettier posts

        Simon Reymann
        Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 11.2M views

        Our whole DevOps stack consists of the following tools:

        • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
        • Respectively Git as revision control system
        • SourceTree as Git GUI
        • Visual Studio Code as IDE
        • CircleCI for continuous integration (automatize development process)
        • Prettier / TSLint / ESLint as code linter
        • SonarQube as quality gate
        • Docker as container management (incl. Docker Compose for multi-container application management)
        • VirtualBox for operating system simulation tests
        • Kubernetes as cluster management for docker containers
        • Heroku for deploying in test environments
        • nginx as web server (preferably used as facade server in production environment)
        • SSLMate (using OpenSSL) for certificate management
        • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
        • PostgreSQL as preferred database system
        • Redis as preferred in-memory database/store (great for caching)

        The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

        • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
        • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
        • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
        • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
        • Scalability: All-in-one framework for distributed systems.
        • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
        See more
        Simon Reymann
        Senior Fullstack Developer at QUANTUSflow Software GmbH · | 24 upvotes · 4.9M views

        Our whole Vue.js frontend stack (incl. SSR) consists of the following tools:

        • Nuxt.js consisting of Vue CLI, Vue Router, vuex, Webpack and Sass (Bundler for HTML5, CSS 3), Babel (Transpiler for JavaScript),
        • Vue Styleguidist as our style guide and pool of developed Vue.js components
        • Vuetify as Material Component Framework (for fast app development)
        • TypeScript as programming language
        • Apollo / GraphQL (incl. GraphiQL) for data access layer (https://apollo.vuejs.org/)
        • ESLint, TSLint and Prettier for coding style and code analyzes
        • Jest as testing framework
        • Google Fonts and Font Awesome for typography and icon toolkit
        • NativeScript-Vue for mobile development

        The main reason we have chosen Vue.js over React and AngularJS is related to the following artifacts:

        • Empowered HTML. Vue.js has many similar approaches with Angular. This helps to optimize HTML blocks handling with the use of different components.
        • Detailed documentation. Vue.js has very good documentation which can fasten learning curve for developers.
        • Adaptability. It provides a rapid switching period from other frameworks. It has similarities with Angular and React in terms of design and architecture.
        • Awesome integration. Vue.js can be used for both building single-page applications and more difficult web interfaces of apps. Smaller interactive parts can be easily integrated into the existing infrastructure with no negative effect on the entire system.
        • Large scaling. Vue.js can help to develop pretty large reusable templates.
        • Tiny size. Vue.js weights around 20KB keeping its speed and flexibility. It allows reaching much better performance in comparison to other frameworks.
        See more
        JSLint logo

        JSLint

        61
        0
        A Code Quality Tool for Javascript
        61
        0
        PROS OF JSLINT
          Be the first to leave a pro
          CONS OF JSLINT
            Be the first to leave a con

            related JSLint posts

            JSHint logo

            JSHint

            921
            0
            A Static Code Analysis Tool for JavaScript
            921
            0
            PROS OF JSHINT
              Be the first to leave a pro
              CONS OF JSHINT
              • 1
                Non-intuitive configuration

              related JSHint posts

              Joshua Dean Küpper
              CEO at Scrayos UG (haftungsbeschränkt) · | 1 upvote · 89.8K views

              We use ESLint because we like to remove the general thinking-overhead when writing software. ESLint offers many presets, while also providing users with a lot of customization features. We use ESLint in conjunction with the javascript "standard" configuration (and for our vueJS-projects the "recommended" settings).

              The other option we considered was JSHint, but we scrapped that, as forward-compatibility is essential for us and ESLint is more fast-paced in its development and supports ESnext natively.

              See more
              SonarQube logo

              SonarQube

              1.7K
              53
              Continuous Code Quality
              1.7K
              53
              PROS OF SONARQUBE
              • 26
                Tracks code complexity and smell trends
              • 16
                IDE Integration
              • 9
                Complete code Review
              • 2
                Difficult to deploy
              CONS OF SONARQUBE
              • 7
                Sales process is long and unfriendly
              • 7
                Paid support is poor, techs arrogant and unhelpful
              • 1
                Does not integrate with Snyk

              related SonarQube posts

              Simon Reymann
              Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 11.2M views

              Our whole DevOps stack consists of the following tools:

              • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
              • Respectively Git as revision control system
              • SourceTree as Git GUI
              • Visual Studio Code as IDE
              • CircleCI for continuous integration (automatize development process)
              • Prettier / TSLint / ESLint as code linter
              • SonarQube as quality gate
              • Docker as container management (incl. Docker Compose for multi-container application management)
              • VirtualBox for operating system simulation tests
              • Kubernetes as cluster management for docker containers
              • Heroku for deploying in test environments
              • nginx as web server (preferably used as facade server in production environment)
              • SSLMate (using OpenSSL) for certificate management
              • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
              • PostgreSQL as preferred database system
              • Redis as preferred in-memory database/store (great for caching)

              The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

              • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
              • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
              • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
              • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
              • Scalability: All-in-one framework for distributed systems.
              • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
              See more
              Ganesa Vijayakumar
              Full Stack Coder | Technical Architect · | 19 upvotes · 5.5M views

              I'm planning to create a web application and also a mobile application to provide a very good shopping experience to the end customers. Shortly, my application will be aggregate the product details from difference sources and giving a clear picture to the user that when and where to buy that product with best in Quality and cost.

              I have planned to develop this in many milestones for adding N number of features and I have picked my first part to complete the core part (aggregate the product details from different sources).

              As per my work experience and knowledge, I have chosen the followings stacks to this mission.

              UI: I would like to develop this application using React, React Router and React Native since I'm a little bit familiar on this and also most importantly these will help on developing both web and mobile apps. In addition, I'm gonna use the stacks JavaScript, jQuery, jQuery UI, jQuery Mobile, Bootstrap wherever required.

              Service: I have planned to use Java as the main business layer language as I have 7+ years of experience on this I believe I can do better work using Java than other languages. In addition, I'm thinking to use the stacks Node.js.

              Database and ORM: I'm gonna pick MySQL as DB and Hibernate as ORM since I have a piece of good knowledge and also work experience on this combination.

              Search Engine: I need to deal with a large amount of product data and it's in-detailed info to provide enough details to end user at the same time I need to focus on the performance area too. so I have decided to use Solr as a search engine for product search and suggestions. In addition, I'm thinking to replace Solr by Elasticsearch once explored/reviewed enough about Elasticsearch.

              Host: As of now, my plan to complete the application with decent features first and deploy it in a free hosting environment like Docker and Heroku and then once it is stable then I have planned to use the AWS products Amazon S3, EC2, Amazon RDS and Amazon Route 53. I'm not sure about Microsoft Azure that what is the specialty in it than Heroku and Amazon EC2 Container Service. Anyhow, I will do explore these once again and pick the best suite one for my requirement once I reached this level.

              Build and Repositories: I have decided to choose Apache Maven and Git as these are my favorites and also so popular on respectively build and repositories.

              Additional Utilities :) - I would like to choose Codacy for code review as their Startup plan will be very helpful to this application. I'm already experienced with Google CheckStyle and SonarQube even I'm looking something on Codacy.

              Happy Coding! Suggestions are welcome! :)

              Thanks, Ganesa

              See more
              Babel logo

              Babel

              22.3K
              391
              Use next generation JavaScript, today.
              22.3K
              391
              PROS OF BABEL
              • 165
                Modern Javascript works with all browsers
              • 77
                Open source
              • 60
                Integration with lots of tools
              • 56
                Easy setup
              • 26
                Very active on github
              • 2
                JSX
              • 2
                Love
              • 2
                Source maps
              • 1
                Extensions
              CONS OF BABEL
                Be the first to leave a con

                related Babel posts

                Nick Parsons
                Building cool things on the internet 🛠️ at Stream · | 35 upvotes · 4.3M views

                Winds 2.0 is an open source Podcast/RSS reader developed by Stream with a core goal to enable a wide range of developers to contribute.

                We chose JavaScript because nearly every developer knows or can, at the very least, read JavaScript. With ES6 and Node.js v10.x.x, it’s become a very capable language. Async/Await is powerful and easy to use (Async/Await vs Promises). Babel allows us to experiment with next-generation JavaScript (features that are not in the official JavaScript spec yet). Yarn allows us to consistently install packages quickly (and is filled with tons of new tricks)

                We’re using JavaScript for everything – both front and backend. Most of our team is experienced with Go and Python, so Node was not an obvious choice for this app.

                Sure... there will be haters who refuse to acknowledge that there is anything remotely positive about JavaScript (there are even rants on Hacker News about Node.js); however, without writing completely in JavaScript, we would not have seen the results we did.

                #FrameworksFullStack #Languages

                See more
                Jonathan Pugh
                Software Engineer / Project Manager / Technical Architect · | 25 upvotes · 3M views

                I needed to choose a full stack of tools for cross platform mobile application design & development. After much research and trying different tools, these are what I came up with that work for me today:

                For the client coding I chose Framework7 because of its performance, easy learning curve, and very well designed, beautiful UI widgets. I think it's perfect for solo development or small teams. I didn't like React Native. It felt heavy to me and rigid. Framework7 allows the use of #CSS3, which I think is the best technology to come out of the #WWW movement. No other tech has been able to allow designers and developers to develop such flexible, high performance, customisable user interface elements that are highly responsive and hardware accelerated before. Now #CSS3 includes variables and flexboxes it is truly a powerful language and there is no longer a need for preprocessors such as #SCSS / #Sass / #less. React Native contains a very limited interpretation of #CSS3 which I found very frustrating after using #CSS3 for some years already and knowing its powerful features. The other very nice feature of Framework7 is that you can even build for the browser if you want your app to be available for desktop web browsers. The latest release also includes the ability to build for #Electron so you can have MacOS, Windows and Linux desktop apps. This is not possible with React Native yet.

                Framework7 runs on top of Apache Cordova. Cordova and webviews have been slated as being slow in the past. Having a game developer background I found the tweeks to make it run as smooth as silk. One of those tweeks is to use WKWebView. Another important one was using srcset on images.

                I use #Template7 for the for the templating system which is a no-nonsense mobile-centric #HandleBars style extensible templating system. It's easy to write custom helpers for, is fast and has a small footprint. I'm not forced into a new paradigm or learning some new syntax. It operates with standard JavaScript, HTML5 and CSS 3. It's written by the developer of Framework7 and so dovetails with it as expected.

                I configured TypeScript to work with the latest version of Framework7. I consider TypeScript to be one of the best creations to come out of Microsoft in some time. They must have an amazing team working on it. It's very powerful and flexible. It helps you catch a lot of bugs and also provides code completion in supporting IDEs. So for my IDE I use Visual Studio Code which is a blazingly fast and silky smooth editor that integrates seamlessly with TypeScript for the ultimate type checking setup (both products are produced by Microsoft).

                I use Webpack and Babel to compile the JavaScript. TypeScript can compile to JavaScript directly but Babel offers a few more options and polyfills so you can use the latest (and even prerelease) JavaScript features today and compile to be backwards compatible with virtually any browser. My favorite recent addition is "optional chaining" which greatly simplifies and increases readability of a number of sections of my code dealing with getting and setting data in nested objects.

                I use some Ruby scripts to process images with ImageMagick and pngquant to optimise for size and even auto insert responsive image code into the HTML5. Ruby is the ultimate cross platform scripting language. Even as your scripts become large, Ruby allows you to refactor your code easily and make it Object Oriented if necessary. I find it the quickest and easiest way to maintain certain aspects of my build process.

                For the user interface design and prototyping I use Figma. Figma has an almost identical user interface to #Sketch but has the added advantage of being cross platform (MacOS and Windows). Its real-time collaboration features are outstanding and I use them a often as I work mostly on remote projects. Clients can collaborate in real-time and see changes I make as I make them. The clickable prototyping features in Figma are also very well designed and mean I can send clickable prototypes to clients to try user interface updates as they are made and get immediate feedback. I'm currently also evaluating the latest version of #AdobeXD as an alternative to Figma as it has the very cool auto-animate feature. It doesn't have real-time collaboration yet, but I heard it is proposed for 2019.

                For the UI icons I use Font Awesome Pro. They have the largest selection and best looking icons you can find on the internet with several variations in styles so you can find most of the icons you want for standard projects.

                For the backend I was using the #GraphCool Framework. As I later found out, #GraphQL still has some way to go in order to provide the full power of a mature graph query language so later in my project I ripped out #GraphCool and replaced it with CouchDB and Pouchdb. Primarily so I could provide good offline app support. CouchDB with Pouchdb is very flexible and efficient combination and overcomes some of the restrictions I found in #GraphQL and hence #GraphCool also. The most impressive and important feature of CouchDB is its replication. You can configure it in various ways for backups, fault tolerance, caching or conditional merging of databases. CouchDB and Pouchdb even supports storing, retrieving and serving binary or image data or other mime types. This removes a level of complexity usually present in database implementations where binary or image data is usually referenced through an #HTML5 link. With CouchDB and Pouchdb apps can operate offline and sync later, very efficiently, when the network connection is good.

                I use PhoneGap when testing the app. It auto-reloads your app when its code is changed and you can also install it on Android phones to preview your app instantly. iOS is a bit more tricky cause of Apple's policies so it's not available on the App Store, but you can build it and install it yourself to your device.

                So that's my latest mobile stack. What tools do you use? Have you tried these ones?

                See more
                SonarLint logo

                SonarLint

                173
                16
                An IDE extension to detect and fix issues as you write code
                173
                16
                PROS OF SONARLINT
                • 13
                  IDE Integration
                • 3
                  Free
                CONS OF SONARLINT
                • 3
                  Non contextual warnings
                • 3
                  Not Very User Friendly

                related SonarLint posts

                Git logo

                Git

                297.5K
                6.6K
                Fast, scalable, distributed revision control system
                297.5K
                6.6K
                PROS OF GIT
                • 1.4K
                  Distributed version control system
                • 1.1K
                  Efficient branching and merging
                • 959
                  Fast
                • 845
                  Open source
                • 726
                  Better than svn
                • 368
                  Great command-line application
                • 306
                  Simple
                • 291
                  Free
                • 232
                  Easy to use
                • 222
                  Does not require server
                • 27
                  Distributed
                • 22
                  Small & Fast
                • 18
                  Feature based workflow
                • 15
                  Staging Area
                • 13
                  Most wide-spread VSC
                • 11
                  Role-based codelines
                • 11
                  Disposable Experimentation
                • 7
                  Frictionless Context Switching
                • 6
                  Data Assurance
                • 5
                  Efficient
                • 4
                  Just awesome
                • 3
                  Github integration
                • 3
                  Easy branching and merging
                • 2
                  Compatible
                • 2
                  Flexible
                • 2
                  Possible to lose history and commits
                • 1
                  Rebase supported natively; reflog; access to plumbing
                • 1
                  Light
                • 1
                  Team Integration
                • 1
                  Fast, scalable, distributed revision control system
                • 1
                  Easy
                • 1
                  Flexible, easy, Safe, and fast
                • 1
                  CLI is great, but the GUI tools are awesome
                • 1
                  It's what you do
                • 0
                  Phinx
                CONS OF GIT
                • 16
                  Hard to learn
                • 11
                  Inconsistent command line interface
                • 9
                  Easy to lose uncommitted work
                • 8
                  Worst documentation ever possibly made
                • 5
                  Awful merge handling
                • 3
                  Unexistent preventive security flows
                • 3
                  Rebase hell
                • 2
                  Ironically even die-hard supporters screw up badly
                • 2
                  When --force is disabled, cannot rebase
                • 1
                  Doesn't scale for big data

                related Git posts

                Simon Reymann
                Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 11.2M views

                Our whole DevOps stack consists of the following tools:

                • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
                • Respectively Git as revision control system
                • SourceTree as Git GUI
                • Visual Studio Code as IDE
                • CircleCI for continuous integration (automatize development process)
                • Prettier / TSLint / ESLint as code linter
                • SonarQube as quality gate
                • Docker as container management (incl. Docker Compose for multi-container application management)
                • VirtualBox for operating system simulation tests
                • Kubernetes as cluster management for docker containers
                • Heroku for deploying in test environments
                • nginx as web server (preferably used as facade server in production environment)
                • SSLMate (using OpenSSL) for certificate management
                • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
                • PostgreSQL as preferred database system
                • Redis as preferred in-memory database/store (great for caching)

                The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

                • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
                • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
                • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
                • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
                • Scalability: All-in-one framework for distributed systems.
                • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
                See more
                Tymoteusz Paul
                Devops guy at X20X Development LTD · | 23 upvotes · 9.8M views

                Often enough I have to explain my way of going about setting up a CI/CD pipeline with multiple deployment platforms. Since I am a bit tired of yapping the same every single time, I've decided to write it up and share with the world this way, and send people to read it instead ;). I will explain it on "live-example" of how the Rome got built, basing that current methodology exists only of readme.md and wishes of good luck (as it usually is ;)).

                It always starts with an app, whatever it may be and reading the readmes available while Vagrant and VirtualBox is installing and updating. Following that is the first hurdle to go over - convert all the instruction/scripts into Ansible playbook(s), and only stopping when doing a clear vagrant up or vagrant reload we will have a fully working environment. As our Vagrant environment is now functional, it's time to break it! This is the moment to look for how things can be done better (too rigid/too lose versioning? Sloppy environment setup?) and replace them with the right way to do stuff, one that won't bite us in the backside. This is the point, and the best opportunity, to upcycle the existing way of doing dev environment to produce a proper, production-grade product.

                I should probably digress here for a moment and explain why. I firmly believe that the way you deploy production is the same way you should deploy develop, shy of few debugging-friendly setting. This way you avoid the discrepancy between how production work vs how development works, which almost always causes major pains in the back of the neck, and with use of proper tools should mean no more work for the developers. That's why we start with Vagrant as developer boxes should be as easy as vagrant up, but the meat of our product lies in Ansible which will do meat of the work and can be applied to almost anything: AWS, bare metal, docker, LXC, in open net, behind vpn - you name it.

                We must also give proper consideration to monitoring and logging hoovering at this point. My generic answer here is to grab Elasticsearch, Kibana, and Logstash. While for different use cases there may be better solutions, this one is well battle-tested, performs reasonably and is very easy to scale both vertically (within some limits) and horizontally. Logstash rules are easy to write and are well supported in maintenance through Ansible, which as I've mentioned earlier, are at the very core of things, and creating triggers/reports and alerts based on Elastic and Kibana is generally a breeze, including some quite complex aggregations.

                If we are happy with the state of the Ansible it's time to move on and put all those roles and playbooks to work. Namely, we need something to manage our CI/CD pipelines. For me, the choice is obvious: TeamCity. It's modern, robust and unlike most of the light-weight alternatives, it's transparent. What I mean by that is that it doesn't tell you how to do things, doesn't limit your ways to deploy, or test, or package for that matter. Instead, it provides a developer-friendly and rich playground for your pipelines. You can do most the same with Jenkins, but it has a quite dated look and feel to it, while also missing some key functionality that must be brought in via plugins (like quality REST API which comes built-in with TeamCity). It also comes with all the common-handy plugins like Slack or Apache Maven integration.

                The exact flow between CI and CD varies too greatly from one application to another to describe, so I will outline a few rules that guide me in it: 1. Make build steps as small as possible. This way when something breaks, we know exactly where, without needing to dig and root around. 2. All security credentials besides development environment must be sources from individual Vault instances. Keys to those containers should exist only on the CI/CD box and accessible by a few people (the less the better). This is pretty self-explanatory, as anything besides dev may contain sensitive data and, at times, be public-facing. Because of that appropriate security must be present. TeamCity shines in this department with excellent secrets-management. 3. Every part of the build chain shall consume and produce artifacts. If it creates nothing, it likely shouldn't be its own build. This way if any issue shows up with any environment or version, all developer has to do it is grab appropriate artifacts to reproduce the issue locally. 4. Deployment builds should be directly tied to specific Git branches/tags. This enables much easier tracking of what caused an issue, including automated identifying and tagging the author (nothing like automated regression testing!).

                Speaking of deployments, I generally try to keep it simple but also with a close eye on the wallet. Because of that, I am more than happy with AWS or another cloud provider, but also constantly peeking at the loads and do we get the value of what we are paying for. Often enough the pattern of use is not constantly erratic, but rather has a firm baseline which could be migrated away from the cloud and into bare metal boxes. That is another part where this approach strongly triumphs over the common Docker and CircleCI setup, where you are very much tied in to use cloud providers and getting out is expensive. Here to embrace bare-metal hosting all you need is a help of some container-based self-hosting software, my personal preference is with Proxmox and LXC. Following that all you must write are ansible scripts to manage hardware of Proxmox, similar way as you do for Amazon EC2 (ansible supports both greatly) and you are good to go. One does not exclude another, quite the opposite, as they can live in great synergy and cut your costs dramatically (the heavier your base load, the bigger the savings) while providing production-grade resiliency.

                See more