Former OceanGate contractor Antonella Wilby revealed that the imploded submersible relied on handwritten coordinates and Excel spreadsheets.

When You Hear How the Doomed Titanic Sub's Sonar System Worked, You May Die of Secondhand Embarrassment

Sonar

sonar

Developers are always concerned about their code quality. And they try their best to ensure the best quality of their code. If they find some tools that can show them exactly where they need to make changes to improve the quality of the code. There are many of them, but I will explain how you can set up SonarQube locally with docker so that you can evaluate your project code quality. Without wasting any time let’s begin. Prerequisite You must have docker installed in your system. If you don’t have it installed, then please feel free to set up Docker using this link. Docker Container On your root project, create a docker-compose.yml file, and then we will need a database so that Sonarqube can store its analytical data. postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data After that, we will need Sonarqube service, sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres Don’t worry; I will explain each line. sonarqube:
This defines a service in your Docker Compose file. The name of the service is sonarqube, meaning that this section is describing how the SonarQube container will run.


image: sonarqube:latest
This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub.


restart: always
This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted.


ports:
- 9000:9000:
This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000.


SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
Defines the JDBC URL to connect SonarQube to a PostgreSQL database.


SONARQUBE_JDBC_USERNAME: postgres:
The username used to authenticate with the PostgreSQL database. In this case, it's postgres.


SONARQUBE_JDBC_PASSWORD: example:
The password used to authenticate the PostgreSQL database, set to example. The final version of our docker-compose.yml file will be the following services:
  postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data

  sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres

networks:
  lookup:

volumes:
  postgres:
    driver: local Inside your project directory, open a terminal, and to start and run the services do docker-compose up . Setup SonarQube Once the services are running on a browser, go to localhost:9000, and it will open the Sonarqube log-in page. The default username and password is admin. Once you are logged in, it will ask you to set up a new password. After completing these steps, you will be able to see the Sonarqube dashboard. As we are running the Sonarqube locally, we will create a local project. In the below, you will see the marked section that you have to click. It will ask for a project name and a branch name. I will leave the branch name as main. You can choose any branch that you have and create a project. Then we will see a new section where we have to choose Use the global setting  for now. Once we click on  create project, it should ask to generate a token. I will only update the Expires in section and make it to No Expiration. Once we generate a token, it will ask us to select our project coding language; after choosing that, we need to download the scanner zip folder. I have marked the section where you will find it below. Let’s unzip the folder and open the folder; you will find the bin folder, and inside, you will find a sonar-scanner file. Copy the path of that file, and save it in a text file. ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin After that, you need to copy the command given in the Execute the Scanner section. Once you copy that, then concat with the path that you have saved in the file as shown below. ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin/sonar-scanner \
   -Dsonar.projectKey=demo   \
   -Dsonar.sources=.   \
   -Dsonar.host.url=http://localhost:9000   \
   -Dsonar.token=<Your_Token> Once you execute the command in the terminal, it will start analyzing your code. Once it finishes the operation, you should see some analytical information in the Sonarqube dashboard. And then, you should be able to see some metrics, and if you have any issues, you should be able to see the reasons for marking it as an issue. Great, we have completed the setup of our Sonarqube on our project locally. Developers are always concerned about their code quality. And they try their best to ensure the best quality of their code. If they find some tools that can show them exactly where they need to make changes to improve the quality of the code. There are many of them, but I will explain how you can set up SonarQube locally with docker so that you can evaluate your project code quality. Without wasting any time let’s begin. Prerequisite You must have docker installed in your system. If you don’t have it installed, then please feel free to set up Docker using this link . link Docker Container On your root project, create a docker-compose.yml file, and then we will need a database so that Sonarqube can store its analytical data. postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data After that, we will need Sonarqube service, sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres Don’t worry; I will explain each line. sonarqube:
This defines a service in your Docker Compose file. The name of the service is sonarqube, meaning that this section is describing how the SonarQube container will run. image: sonarqube:latest
This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub. restart: always
This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted. ports:
- 9000:9000:
This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000. SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
Defines the JDBC URL to connect SonarQube to a PostgreSQL database. SONARQUBE_JDBC_USERNAME: postgres:
The username used to authenticate with the PostgreSQL database. In this case, it's postgres. SONARQUBE_JDBC_PASSWORD: example:
The password used to authenticate the PostgreSQL database, set to example. sonarqube: This defines a service in your Docker Compose file. The name of the service is sonarqube, meaning that this section is describing how the SonarQube container will run. sonarqube: sonarqube: This defines a service in your Docker Compose file. The name of the service is sonarqube , meaning that this section is describing how the SonarQube container will run. sonarqube image: sonarqube:latest This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub. image: sonarqube:latest image: sonarqube:latest This specifies the Docker image to use for the SonarQube service. In this case, it pulls the latest version of the official SonarQube image from Docker Hub. restart: always This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted. restart: always restart: always This ensures that the SonarQube container will automatically restart if it crashes or if the Docker host is rebooted. ports: - 9000:9000: This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000. ports: ports: - 9000:9000 : - 9000:9000 This maps port 9000 on the host machine to port 9000 inside the container. SonarQube’s web interface runs on port 9000, so this makes it accessible from the host machine's browser at http://localhost:9000 . http://localhost:9000 SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres Defines the JDBC URL to connect SonarQube to a PostgreSQL database. SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres Defines the JDBC URL to connect SonarQube to a PostgreSQL database. SONARQUBE_JDBC_USERNAME: postgres: The username used to authenticate with the PostgreSQL database. In this case, it's postgres. SONARQUBE_JDBC_USERNAME: postgres : SONARQUBE_JDBC_USERNAME: postgres The username used to authenticate with the PostgreSQL database. In this case, it's postgres . postgres SONARQUBE_JDBC_PASSWORD: example: The password used to authenticate the PostgreSQL database, set to example. SONARQUBE_JDBC_PASSWORD: example : SONARQUBE_JDBC_PASSWORD: example The password used to authenticate the PostgreSQL database, set to example . example The final version of our docker-compose.yml file will be the following services:
  postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data

  sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres

networks:
  lookup:

volumes:
  postgres:
    driver: local services:
  postgres:
    image: postgres
    restart: always
    environment:
      POSTGRES_PASSWORD: example
    networks:
      - lookup
    ports:
      - 5432:5432
    volumes:
      - postgres:/var/lib/postgresql/data

  sonarqube:
    image: sonarqube:latest
    restart: always
    ports:
      - 9000:9000
    environment:
      SONARQUBE_JDBC_URL: jdbc:postgresql://postgres:5432/postgres
      SONARQUBE_JDBC_USERNAME: postgres
      SONARQUBE_JDBC_PASSWORD: example
    networks:
      - lookup
    depends_on:
      - postgres

networks:
  lookup:

volumes:
  postgres:
    driver: local Inside your project directory, open a terminal, and to start and run the services do docker-compose up . docker-compose up Setup SonarQube Once the services are running on a browser, go to localhost:9000 , and it will open the Sonarqube log-in page. The default username and password is admin . Once you are logged in, it will ask you to set up a new password. localhost:9000 admin After completing these steps, you will be able to see the Sonarqube dashboard. As we are running the Sonarqube locally, we will create a local project. In the below, you will see the marked section that you have to click. It will ask for a project name and a branch name. I will leave the branch name as main . You can choose any branch that you have and create a project. Then we will see a new section where we have to choose Use the global setting for now. main Use the global setting Once we click on create project , it should ask to generate a token. I will only update the Expires in section and make it to No Expiration . Once we generate a token, it will ask us to select our project coding language; after choosing that, we need to download the scanner zip folder. I have marked the section where you will find it below. create project Expires in No Expiration Let’s unzip the folder and open the folder; you will find the bin folder, and inside, you will find a sonar-scanner file. Copy the path of that file, and save it in a text file. bin sonar-scanner ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin After that, you need to copy the command given in the Execute the Scanner section. Execute the Scanner Once you copy that, then concat with the path that you have saved in the file as shown below. ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin/sonar-scanner \
   -Dsonar.projectKey=demo   \
   -Dsonar.sources=.   \
   -Dsonar.host.url=http://localhost:9000   \
   -Dsonar.token=<Your_Token> ~./sonar-scanner-cli-6.1.0.4477-linux-x64/sonar-scanner-6.1.0.4477-linux-x64/bin/sonar-scanner \
   -Dsonar.projectKey=demo   \
   -Dsonar.sources=.   \
   -Dsonar.host.url=http://localhost:9000   \
   -Dsonar.token=<Your_Token> Once you execute the command in the terminal, it will start analyzing your code. Once it finishes the operation, you should see some analytical information in the Sonarqube dashboard. And then, you should be able to see some metrics, and if you have any issues, you should be able to see the reasons for marking it as an issue. Great, we have completed the setup of our Sonarqube on our project locally.

How to Setup SonarQube Locally Using Docker

AI code review is becoming more important in software development, ensuring code quality, identifying bugs, and improving overall project maintainability. In recent years, several tools have emerged to automate and streamline the code review process. In this comparative blog, we will explore and compare Metabob, an AI code review tool, against popular static code review tools like Sonarlint, Sonarcloud, and DeepSource. We will also take a look at how some of these solutions utilize Generative AI for user interaction. The bases of comparison are the level of complexity of identified issues and overall user experience. To conduct our comparison, buggy GitHub Repositories were singled out for extensive testing. These repos include: fiatrete/OpenDan opencodeiiita/PhotoStore fief-dev/fief TransformerOptimus/SuperAGI Metabob stands out as a unique AI code review tool that leverages Graph Neural Networks to identify bugs and LLMs to provide automated code recommendations. It analyzes code snippets and offers suggestions for improvement, bug detection, and best coding practices. Sonarlint, developed by SonarSource, is a powerful static code analysis tool that integrates with popular integrated development environments (IDEs) like IntelliJ, Visual Studio Code, and Eclipse. Sonarcloud, also developed by SonarSource, takes static code analysis a step further by offering cloud-based continuous code inspection. It automatically scans code repositories, providing comprehensive reports on code quality, security vulnerabilities, and technical debt. DeepSource is another static code analysis platform that helps identify bugs, security vulnerabilities, and style violations. Complexity Simple, rule-based code reviews Syntax errors, empty variable assignments, and unnecessary complexity are all examples of simple bugs that occur in scripts. In this regard, Sonarlint, SonarCloud, and DeepSource perform very well. They identify such errors quickly and highlight regions of code that are potentially buggy. Metabob is also able to highlight very blatant errors like empty variable assignments, but it does not do well recommending stylistic syntax issues. Metabob glosses over these issues and deems them insignificant. Complex, context-based code reviews Using its attention mechanism from Graph Neural Networks to comprehend semantic and rational markers, Metabob performs much better than its competitors in this aspect. Metabob is able to detect complex, context-based errors, while the other solutions fail to do so. The example below details a script that uses the HS256 algorithm to generate access tokens. Metabob was able to identify the usage of this algorithm and its weakness against certain attacks. Metabob then recommends the replacement of this algorithm with RS256 or ES256 algorithms to prevent such attacks. Another example of complex errors is a race condition. Metabob is able to understand the objective of the function and what it is trying to achieve. It is also contextualizing this objective to the other functions present in the script. This combination of information helps it identify race conditions. Without contextualizing code within and across scripts, SonarLint, SonarCloud, and DeepSource are not able to determine such issues. User Experience SonarCloud and DeepSource are web-based SaaS platforms that take some time to configure and use. They both feature a dashboard that displays statistics about each repository (security, performance, stylistic issues) while allowing users to navigate through different issues. This makes navigation within the platform very user-friendly and organized.\ SonarLint and Metabob are available as integrated extensions on VScode. They operate right out of the IDE, with no complex configurations required. Metabob then takes it a step further to incorporate generative AI into its user experience. Using LLMs, Metabob generates error explanations, answers users’ questions, and even recommends code fixes. This allows users to engage with the tool to better understand the identified issues and bugs. Conclusion While SonarLint, SonarCloud, and DeepSource are the go-to solution when it comes to simple error identification, Metabob's competitive advantage lies in identifying complex errors. This was evident in the repository analysis conducted, where Metabob could detect all the contextual-based errors while the other tools failed to do so. However, Metabob is only available for Python as a programming language for now, and support for more languages is being worked on. Metabob utilizes generative AI to enhance its user experience, keeping the tool interactive. Its unique question-and-answer AI assistant allows users to clarify issues, and the LLM code fix recommendations elevate the coding standard to a higher level. Metabob offers free-to-use individual developer versions and is currently available on VScode as an extension. The tool can be tested here: ! Metabob: Debug and Refactor with AI - Visual Studio Marketplace

AI Code Review: Comparing Metabob with Sonar & DeepSource

All You Need to Know About Continuous Integration, GitHub Actions, & Sonar Cloud

ক্রমাগত ইন্টিগ্রেশন, গিটহাব অ্যাকশন এবং সোনার ক্লাউড সম্পর্কে আপনার যা জানা দরকার

Alles, was Sie über kontinuierliche Integration, GitHub-Aktionen und Sonar Cloud wissen müssen

Todo lo que necesita saber sobre integración continua, acciones de GitHub y Sonar Cloud

Tout ce que vous devez savoir sur l'intégration continue, les actions GitHub et Sonar Cloud

निरंतर एकीकरण, गिटहब क्रियाएँ, और सोनार क्लाउड के बारे में आप सभी को पता होना चाहिए

継続的インテグレーション、GitHub アクション、Sonar Cloud について知っておくべきこと

지속적인 통합, GitHub Actions 및 Sonar Cloud에 대해 알아야 할 모든 것

Tudo o que você precisa saber sobre integração contínua, ações do GitHub e Sonar Cloud

Sürekli Entegrasyon, GitHub Eylemleri ve Sonar Cloud Hakkında Bilmeniz Gereken Her Şey

Tất cả những gì bạn cần biết về tích hợp liên tục, hành động GitHub và đám mây Sonar

关于持续集成、GitHub Actions 和 Sonar Cloud，您需要知道的一切

SonarQube is an open-source tool that helps developers continuously inspect the code quality of their projects. It provides code analysis, code coverage, and code duplication detection, along with various other features. With SonarQube, developers can easily detect and fix the technical debt, improving the quality of their code. Prerequisites Any basic programming language knowledge. Basic OOPS concepts understanding The article demonstrates SonarQube Analysis with C# programming language. Learning Objectives How to do SonarQube analysis via the Docker Image How to analyze C# application via the Docker Image Getting Started Running SonarQube on a local machine can sometimes be cumbersome due to the complex setup requirements, but Docker can simplify the process. Docker is a platform for building, shipping, and running container applications. Docker provides an easy-to-use interface for managing and deploying applications and can be used to run SonarQube. In this article, we will explore the steps to run SonarQube via the Docker image: Step 1: Install Docker The first step to running SonarQube via Docker is to install Docker on your machine. Docker provides installation instructions for different operating systems on their website. Step 2: Pull the SonarQube Image Once Docker is installed, the next step is to pull the SonarQube image from the Docker Hub. You can do this by running the following command in the terminal: docker pull sonarqube This command will download the latest SonarQube image from the Docker Hub. Step 3: Run the SonarQube Container Now that the SonarQube image has been downloaded, the next step is to run the SonarQube container. You can do this by running the following command in the terminal: docker run -d --name sonarqube -p 9000:9000 sonarqube This command will start the SonarQube container and expose port 9000 on the host machine. You can access the SonarQube web interface by opening a web browser and navigating to . http://localhost:9000 Step 4: Analyze Code with SonarQube With the SonarQube container up and running, you can now analyze your code by following these steps: Generate a SonarQube analysis report for your codebase. Copy the report to the SonarQube container. Run the SonarQube analysis by executing the following command: docker exec sonarqube /opt/sonar-scanner/bin/sonar-scanner \
   -Dsonar.projectKey=<project_key> \
   -Dsonar.sources=<path_to_code> \
   -Dsonar.host.url=http://localhost:9000 \
   -Dsonar.login=<token> Analyze a C# application using SonarQube via the Docker image Step 1: Add SonarQube Scanner for MSBuild to your project The SonarScanner for MSBuild is a .NET Core tool that helps to integrate SonarQube analysis into the MSBuild process. You can add the SonarScanner for MSBuild to your project by running the following command in the terminal: dotnet tool install --global dotnet-sonarscanner Step 2: Generate a SonarQube Analysis Report Once the SonarScanner for MSBuild is installed, the next step is to generate a SonarQube analysis report for your C# project. You can do this by running the following command in the terminal: dotnet sonarscanner begin /k:"<project_key>" /d:sonar.host.url="http://localhost:9000" /d:sonar.login="<token>" Replace with a unique identifier for your project and the authentication token for your SonarQube instance. <project_key> <token> This command will begin the SonarQube analysis and generate a report for your C# project. Step 3: Build your C# project Next, build your C# project using the following command: dotnet build This command will compile your C# code and create a binary executable. Step 4: Analyze your C# project with SonarQube Once your C# project is built, you can analyze it with SonarQube by running the following command: dotnet sonarscanner end /d:sonar.login="<token>" This command will end the SonarQube analysis and upload the report to your SonarQube instance. Step 5: View the SonarQube Analysis Results Now that the analysis is complete, you can view the results in the SonarQube web interface by navigating to . In the SonarQube interface, you can see information about code quality, code coverage, and other metrics for your C# project. http://localhost:9000 Conclusion That’s it! Following these steps, you can quickly analyze your C# application using SonarQube via the Docker image. SonarQube can help you identify code quality issues and improve the overall maintainability of your codebase. Also published . here

Analyzing Your Code With SonarQube Running via Docker Image

In this guide, we are going to deploy a continuous integration process between Jenkins, GitLab, and SonarQube. The end goal will be to review the code quality through SonarQube for GitLab repository using Jenkins. Following is the process flow we need to manage: Push code to GitLab from the local machine. Next, checkout code and run tests in Jenkins, here it is acting as a Continuous Integrator. Generate quality report via SonarQube as a code analyser. Setup Jenkins, SonarQube & GitLabs In case, if you haven't set up the required software yet, go through the below-mentioned steps: Step 1: Make sure that your host machine has enough power to run these components, as GitLab alone requires 4 GB of RAM to perform its operations smoothly. To run all three together, you need at least 8 GB of RAM and 20 GB of hard disk space. Step 2: For SonarQube, you need to set the recommended values as a root user on the host machine: $ sysctl -w vm.max_map_count= $ sysctl -w fs.file-max= $ ulimit -n $ ulimit -u 262144 65536 65536 4096 Step 3: For this guide, we are going to use a simple docker-compose.yml file. However, you are free to edit the file as per your requirement. Before launching the containers, please make sure that you change the value of , , , and . Although, along with this, you can also modify the define ports in the file. GITLAB_SECRETS_DB_KEY_BASE GITLAB_HOST SONARQUBE_JDBC_PASSWORD POSTGRES_PASSWORD version: services:
   jenkins:
       image: jenkinsci/jenkins:lts
       container_name: jenkins-container
       restart: always
       ports:
           - - volumes:
       - - environment:
       - gitlab:
       image: gitlab/gitlab-ce:latest
       container_name: gitlab-container
       restart: always
       environment:
           - GITLAB_SECRETS_DB_KEY_BASE=long-and-random-alphanumeric-string
           - GITLAB_HOST=your-host-ip-here
           - GITLAB_PORT= - GITLAB_SSH_PORT= ports:
           - - volumes:
       - - - sonarqube:
       image: sonarqube: -community
       container_name: sonar-container
       restart: always
       networks:
           - sonarnet
       environment:
           - SONARQUBE_JDBC_USERNAME=sonar
           - SONARQUBE_JDBC_PASSWORD=your-strong-password-here
           - SONARQUBE_JDBC_URL=jdbc:postgresql: ports:
       - - volumes:
       - - - - postgressdb:
       image: postgres: container_name: postgres-container
       restart: always
       networks:
           - sonarnet
       environment:
           - POSTGRES_USER=sonar
           - POSTGRES_PASSWORD=your-strong-password-here
           - POSTGRES_DB=sonarqube
       volumes:
       - - networks:
   sonarnet:
    driver: bridge "3.2" "8080:8080" '50000:50000' '/var/run/docker.sock:/var/run/docker.sock' '/data/jenkins/jenkins_home:/var/jenkins_home' "JENKINS_OPTS=--prefix=/jenkins" 10080 10022 "10080:80" "10022:22" '/data/gitlab/config:/etc/gitlab' '/data/gitlab/logs:/var/log/gitlab' '/data/gitlab/data:/var/opt/gitlab' 7.9 .2 //postgressdb:5432/sonarqube "9000:9000" "9092:9092" '/data/sonar/sonarqube_conf:/opt/sonarqube/conf' '/data/sonar/sonarqube_data:/opt/sonarqube/data' '/data/sonar/sonarqube_extensions:/opt/sonarqube/extensions' '/data/sonar/sonarqube_bundled-plugins:/opt/sonarqube/lib/bundled-plugins' 12.1 '/data/postgresql/sonarqube_db:/var/lib/postgresql' '/data/postgresql/postgresql_data:/var/lib/postgresql/data' Now, run the following command to launch the stack: $ docker-compose up -d Note that the installation process is going to take some time, so sit back and have some coffee. You deserve it! Step 4: Now, to verify if all systems are up and running, run this command: $ docker ps

CONTAINER ID    IMAGE                     COMMAND             CREATED         STATUS                  PORTS                                                   NAMES
f54e223417fa    gitlab/gitlab-ce:latest minute ago minute ago (healthy) /tcp, : -> /tcp, : -> /tcp   gitlab-container f03f69b8    sonarqube minute ago minute ago : -> /tcp                                  sonar-container f554da39fc    jenkinsci/jenkins:lts minute ago minute ago : -> /tcp, : -> /tcp        jenkins-container "/assets/wrapper" 1 1 443 0.0 .0 .0 10022 22 0.0 .0 .0 10080 80 9102 "./bin/run.sh" 1 1 0.0 .0 .0 9000 9000 05 "/bin/tini --..." 1 1 0.0 .0 .0 8080 8080 0.0 .0 .0 50000 50000 If all went well, then you can access all three of them by following mentioned URLs: Jenkins - http://your-ip-address:8080 SonarQube - http://your-ip-address:9000 GitLab - http://your-ip-address:10080 As you are visiting your Jenkins environment for the first time, it is going to prompt you to enter the administrator password, which was generated during the installation process. To access the password from the container, you can run the following command: $ docker exec -it <your-jinkins-container-id> cat / /jenkins_home/secrets/initialAdminPassword
$ gSzHTGfbtXSpcBXMyJ6gzmNfNH7BjhK23 var Once you enter the password, you can select the option . Wait until the download finishes. Install suggested plugin For SonarQube, the default username and password are admin and admin, respectively. Whereas, for GitLab, you will be prompted to enter the new password for the default username root. Configuring Jenkins Pipeline with SonarQube and GitLab integration We will begin with SonarQube. To connect it with Jenkins, you need to generate the token to access the SonarQube instance. SonarQube Configuration: Login into the SonarQube dashboard and go to the Administrator tab. In the Security drop-down menu, select User tab as shown in the below image: Here you will find Administrator user, for which you are going to generate the access token: In the pop-up that displays on your screen, enter the desired name and click on the button. Copy the newly generated token and save it somewhere safe, as you won’t be able to view/copy the generated token again. Generate To establish a connection between GitLab and Jenkins, again, we need to generate an access token, which can be done as mentioned below: GitLab Configuration: To generate an access token, go to your GitLab dashboard and follow . Once you have the token with you, copy it for further use. Dashboard > Setting > Access Tokens This guide assumes that you have already done the basic setup for Jenkins. Now, let’s move to configure GitLab and SonarQube in the Jenkins server. Integrating SonarQube and GitLabs in Jenkins: First, we are going to integrate SonarQube. Go and search for SonarQube. Dashboard > Manage Jenkins > Manage Plugins Make sure you restart Jenkins once the plugin is successfully installed. Once the restart is completed, you have to set up Sonar Scanner, which is a standalone tool used for scanning the source code and send the result to SonarQube Server. Here you are going to install it in the Jenkins container itself, although you are free to launch a separate container for the same purpose. $ docker exec -it <your-jinkins-container-id> bash

$ cd / /jenkins_home

$ wget https: $ unzip sonar-scanner-cli -linux.zip var //binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-4.2.0.1873-linux.zip -4.2 .0 .1873 Go back to the Manage Jenkins page and select Global Tool Configuration. In this page, find SonarQube Scanner and add complete the installation: Don’t forget to uncheck as you have to define the installation path of Sonar Scanner explicitly. Install automatically As Jenkins and SonarQube are running in separate docker containers, we need to create a Webhook at SonarQube Server so that both can communicate with each other. To do so, follow : Dashboard > Administrator > Configuration > Webhook Lastly, you have to add the access token you generated on your SonarQube server in Jenkins. Follow the URL or go to , as shown below: http://your-ip-addr-here:8080/credentials/store/system/ Dashboard > Credentials > System Click on link and select “Secret Text” field under : Add Credentials Kind In the Secret field, paste the generated token from SonarQube that you previously created. Now, add the SonarQube server to your Jenkins environment. Go to . Find on the page and add the required details as mentioned below: Dashboard > Manage Jenkins > Configure System SonarQube server Now, you have to add Gitlab in Jenkins, visit . Here, you are going to add the access token you previously created to your Jenkins server. Although, you can also use with username and password. Dashboard > Credentials > System Kind As you are through with the SonarQube and GitLab integration in Jenkins, it’s time to manage other dependencies. In this guide, we are going to use a simple NodeJs application; hence it’s time to install NodeJS on your Jenkins Server. NodeJS Environment in Jenkins: To install NodeJS plugin, go to and search and select NodeJS. Click on the button, as shown in the figure below. Dashboard > Manage Jenkins > Manage Plugins > Available Install without restart Upon successful installation of NodeJS plugin in Jenkins, make sure that you restart Jenkins. To configure NodeJS plugin, go to and find "NodeJS". Click on NodeJS installation button and add the necessary details, as shown in the figure: Dashboard > Manage Jenkins > Global Tool Configuration Give a name and select the NodeJS version as per your requirement; you can also install Global NPM packages and set the refresh rate depending upon the project requirements. Once done, you need to save the configuration. As we are through with the gruesome part of installing and configuring the environment, it’s time to create the project pipeline. Creating Jenkins Pipeline Here you are going to create a pipeline using Declarative Scripted Pipeline. Follow the below steps to get started: Go to Jenkins’ Dashboard and click on the “New Item” link. Now, enter the item name and select option as shown in the figure: Step 1 - Create a New Job Pipeline The below-mentioned simple pipeline script helps you to pull the code from GitLab, quality check via SonarQube, and use NodeJS. Step 2 - Pipeline pipeline {
agent any
tools {nodejs }
stages {
 stage( ) {
  steps {
   git branch: , : , : }
 }
   stage( ) {
   steps {
       script {
       def scannerHome = tool ;
           withSonarQubeEnv( ) {
           sh sonarqube }
           }
       }
   }
   stage( ) {
   steps {
       nodejs(nodeJSInstallationName: ){
           sh }
       }
   }
}
} "nodenv" "Code Checkout from GitLab" 'master' credentialsId 'gitlab_access_token' url 'http://your-ip-here:10080/root/test-project.git' 'Code Quality Check via SonarQube' 'sonarqube' "sonarqube-container" "${tool(" ")}/bin/sonar-scanner \
           -Dsonar.projectKey=test-node-js \
           -Dsonar.sources=. \
           -Dsonar.css.node=. \
           -Dsonar.host.url=http://your-ip-here:9000 \
           -Dsonar.login=your-generated-token-from-sonarqube-container" "Install Project Dependencies" 'nodenv' "npm install" Make sure that you change the values of GitLab repo URL, SonarQube host URL, and its access token. Add the above-mentioned pipeline script and save it, as shown in the below figure: Now, as you have saved the pipeline script, it’s time to build your application in Jenkins. Go to . Step 3 - Run Pipeline Dashboard > YOUR PROJECT > Build Now As soon as you click the link, Jenkins will start building project as per pipeline script. In Build History, you will see the progress bar for the current build along with the Stage View: Build Now If your build runs successfully, you will be able to see the time taken by each stage, in : Stage View Also, you can visit the SonarQube dashboard to see the project code report, by visiting the link named as "SonarQube" on project pipeline page. That’s it! You have successfully created a Jenkins Pipeline while using SonarQube and GitLab. Now, every time you push the code to the repo, you can build the project, which will show the code quality.

Workflow Automation: Jenkins Pipeline with Sonarqube and Gitlab

As developers, there always comes a time when we find a bug in production and wonder how it passed all our quality checks. The truth is that we can never be sure our code is bug free. We can only choose the tools and workflows which will find the most bugs without slowing us down too much. SonarQube, SonarLint and SonarCloud are such tools. We used SonarCloud during our recent bug report campaign, which focused on popular projects such as , , , and . The campaign result was quite interesting, since it shows the kind of bugs we can find in a Python project even when its development workflow includes every best practice: code reviews, high test coverage, and the use of one or more linters (flake8, pylint, ...). tensorflow numpy salt sentry biopython Let's go over a few Bugs we found with SonarCloud and see why it is able to detect them when popular linters don't . Reference to an undefined variable SonarCloud can detect buggy references to undefined variables when the variables are defined in another branch. It uses a to deduce that the definition of the variable will never occur before the buggy reference. if-else Control Flow Graph Unreachable code Detecting dead code is easy when it's just after a or a statement. It's a little harder when the is conditional. We use a control flow graph to detect cases where multiple branches exit just before reaching a statement. return raise return Wrong fields in formatted strings It is quite common to reference the wrong field name or index during string formatting. Pylint and Flake8 have rules detecting this problem with string literals, but they miss bugs when the format string is in a variable. Type errors SonarCloud has a type inference engine, which enables it to detect advanced type errors. It uses every bit of information it can find to deduce variable type, including stubs, assignments, and your type annotations.. At the same time, it won't complain if you don't use type annotations, and it's designed to avoid False Positives. Typeshed In this example, control flow analysis is what allows it to understand that is a tuple because it is assigned when is a . The algorithm is able to ignore the later assignments to . state_shape output_shape[1:] output_shape tuple list output_shape Now let's look at some more specific examples. Wrong argument type SonarCloud uses stubs to know the types expected by builtins functions. So here it raises an issue because you get a if you call the builtin on an integer. Typeshed TypeError len Comparisons that don't make sense SonarCloud has many rules detecting code which doesn't make sense. Comparing incompatible types with will never fail, but it will always return False, or True if you use . Here we can see an issue because returns a tuple. == != platform.architecture() Return values from functions without side effects should not be ignored Some function calls have no side effect, i.e. they won't change anything by themselves and their only purpose is to return a value. Thus  there is always a bug when their result is not used. SonarCloud knows an extensive list of such functions. In this example the two strings are not concatenated; the method is called on the second string and the result is discarded, so the value of is "Make sure that your dataset can generate at least ". format warning_msg Unraised exceptions When we review code we usually look at classes, variables and other meaningful symbols and we forget to check little details, such as "is there a raise keyword before my exception". SonarCloud analyzes your whole project to extract type hierarchies. Thus it detects when custom exceptions are discarded, not just the builtin ones. Flake8 is great but not enough Some of the things [SonarCloud] spots are impressive (probably driven by some introspection and/or type inference), not just the simple pattern matching that I am used to in most of the flake8 ecosystem. - Peter J. A. Cock - maintainer of BioPython ( original post here ) This is one of the nice pieces of feedback we received during our bug report campaign. ( !). There's more All the projects we examined use one or more linters, such as Flake8, which is very popular, and is often included in CI workflows. There are very good reasons for Flake8's broad use: it focuses on uncontroversial rules that generate few false positives It checks pep8 style It is fast , and have the same philosophy about speed and false positives. All three target developers, which means that . In addition, SonarCloud and SonarQube can both import Flake8 issues. But most importantly: SonarLint SonarCloud SonarQube we work hard to keep "noise" to a minimum they detect a broader range of issues. Not just style and pattern matching, but a full range of . bugs, code smells and vulnerabilities they help you focus on achieving high quality in recent changes (i.e. ) rather than distracting you with small flaws in old code Clean as You Code they support all the languages in your project. For example if you've got JavaScript or TypeScript alongside your Python, it will be analyzed simultaneously, with no more setup or infrastructure. You can use SonarCloud for free on any open source project and get started with just a few clicks. is also free for unlimited on-premises use. Don't hesitate to share your feedback, good or bad, . It helps us improve our tools everyday. SonarQube Community Edition in our community forum Previously published at https://blog.sonarsource.com/sonarcloud-finds-bugs-in-high-quality-python-projects

The Ultimate Guide To Hassle Free Bugs Fixing In Premium Python Projects By SonarCloud 

Late feedback is a pain in the butt. Regardless of how it comes, hearing "that thing you did two weeks ago was wrong" is unwelcome at best. Good feedback is immediate, actionable and at least dispassionate, if not compassionate. That's why we help you integrate C++ static analysis throughout your workflow, so you and your team get the feedback you need when and where it's most useful. In this post, I'll walk through how SonarQube and SonarLint integrate smoothly into your workflow and your team to give you the right data at the right time and in the right place. Most experienced developers understand that coding is a bit of a team sport. Success requires both individual performances as well as cooperation and, well, teamwork. That's where SonarQube comes in. It helps teams coalesce around shared standards and a shared vision of quality. The two biggest pieces of this are the Quality Profile and the Quality Gate. Your code; your standards A Quality Profile is a subset of rules applied during analysis to raise issues on your code. The out-of-the-box profile is named "Sonar way", and we work hard to make sure the Sonar way profile for each language is uncontroversial. Currently Sonar way for C++ consists of nearly 300 rules, 44 of which tie back to the championed by Bjarne Stroustrup and Herb Sutter. The idea with the default profile is that your first analysis should only raise "no brainer" issues; ones that most people will obviously want to fix (E.G. null pointer dereferences). C++ Core Guidelines But narrowing the profile to only uncontroversial rules, means that we've omitted the rules for special situations. For instance, beyond the 44 C++ Core Guidelines rules in the default profile, we've implemented another 18 rules that aren't in the default profile. Why? There are a few different reasons. First, some only make sense when you're writing very modern C++, but would be very noisy on code written in an older style. Another sub-set is more stylistic than anything else, and there's no consensus about those rules even if they are in the core guidelines. But anyway, those rules - and a lot more - are available, and you can easily add them to your own custom profiles to make sure you apply the best rules for your team and your code base. The other big piece of coalescing the team around shared standards is the Quality Gate, which is the list of boolean conditions  (E.G. test coverage on new code > 80%) your project must meet to be considered releasable. Again, we provide what we believe to be a sane default. But the idea is that you'll set your Quality Gate up to reflect what sees as the minimum standards to release to production. your team At every analysis, the project is tested against those conditions to yield a pass/fail releasability status so you always know whether your code meets minimum quality standards for release. And with webhooks, we make it easy to reflect your Quality Gate status back to your pipeline, allowing you to fail the build if you need to. your own Earlier is better: PR analysis But of course, the earlier feedback comes, the better. Personally, I'd rather know there's a problem I break the whole team's build. That's why we've implemented pull request analysis and decoration both on-prem and in-cloud for GitHub, GitLab and Azure DevOps, as well as for Bitbucket Server. before The setup for this can be inherited from the main build, with the addition of a few extra PR-specific parameters. But if you're using Jenkins, Cirrus CI or GitLab CI, even that's taken care of for you. In those CIs we read the PR values from the environment so there's nothing extra to do. Then, with the addition of a little one-time configuration in your SonarQube project, you can have your PR annotated in GitHub/GitLab/etc with the analysis results and Quality Gate status. The obvious advantage is that your static analysis results are delivered to you in the interface you're already using; you don't have to go looking for them. That's great from both sides of the peer-review equation. As a PR submitter, you get early notice of the simple stuff so you can get it cleaned up before you ever ask for review. And as a reviewer, you can come to a PR knowing the team standards have already been met. No more arguments about whether `const` should be used. That's baked into the team's Quality Profile and already taken care of by the time you see the code. All you have to do is focus on the logic of the PR: does it fulfill the requirement in an optimal fashion? Earliest is best: in-IDE analysis But of course, the earlier feedback comes, the better. Personally, I'd rather know there's a problem I commit. That's why we've created SonarLint, which is a free plugin for Visual Studio. With each save, the file you're working on is re-analyzed so any new issues are raised to you immediately and you can fix them before commit. before If you have any questions about why there's a problem with your code, the rule description is close at hand. It'll help you understand what could go wrong, and give you code samples demonstrating a fix. By connecting SonarLint to your project in SonarQube, you can make the experience even better. Out of the box, SonarLint applies the Sonar way Quality Profile. Once you're in connected mode, the Quality Profile chosen by your team is applied instead. Not only that, but connected mode also syncs issues that you and your teammates have marked Won't Fix or False Positive on the server, so that you're never bothered with them in SonarLint. Quality; full circle And that brings us full circle. SonarQube allows the team to coalesce around a shared vision of quality ( rules, release criteria). With pull request analysis, you can apply that vision to your code not just before merge, but even before peer review. SonarLint brings static analysis into your IDE, and SonarLint's connected mode pulls in the team's standards from SonarQube. these those Developer surveys show that most C++ developers are seasoned, with at least 5 years' experience and more likely 10 years or more. That means you've both mastered your craft and come to realize how much you still know. don't You've seen the language grow and evolve, and understand that more change is always in store. You're past wanting to reinvent the wheel, and happy to exploit the tools at hand with minimum effort for maximum benefit. And that's where SonarQube and SonarLint static analysis come in. They'll help you stay on top of not just absentminded goofs and evolving language standards, but also the tricky bugs that only show up under the right conditions. (Also published ) here ( : ) Disclaimer The author works at SonarSource

How To Get Accurate Feedback From The SonarQube Ecosystem Into C++ Directly

Optimizing workflows with AI has become a game-changer for me, especially when it comes to searching for information. For a while, I relied on the free version of Perplexity, but recently, I upgraded to Perplexity Pro. Meanwhile, as a longtime user of ChatGPT, I’ve also been exploring its new ChatGPT Search feature. In this article, I’ll share my experiences with both tools, compare their strengths and weaknesses, and help you decide which one might be the better fit for your needs. Perplexity I’d heard about Perplexity.ai many times, promised myself I’d try it, and eventually did, but it didn’t quite click. It’s hard to fully appreciate a tool until you use it regularly. I forgot about it until I got a test assignment for a job interview in a new field, requiring tons of research. Honestly, I’m not great at googling. But since I frequently use ChatGPT and have gotten pretty good at writing prompts, I thought of giving Perplexity another shot. This was before the release of ChatGPT Search, and at that point, I’d already maxed out what ChatGPT could offer. Perplexity turned out to be a lifesaver. It made long, tedious searches much quicker and was my first truly game-changing experience with AI search. At the time, I used the free version. Compared to browser searches, here’s what I found more convenient in AI search: Fewer distractions from ads: Most browsers put ads at the top, so you have to scroll past them just to get to the first actual search result. Even without the ads, the top links are often not very relevant, and there are still too many to sift through. This makes it easy to lose motivation to click beyond the first couple of pages. AI does all that for you, providing a list of sources you can explore further on your own.


Threaded searches with context: I loved how searches are organized into threads, preserving context. For my test assignment, since I was learning a new field from scratch, one question would lead to many others. It was convenient to continue and expand the search without starting over each time. If I remembered something later, I could easily return to a specific thread and pick up where I left off.


Helpful question suggestions: Each thread in Perplexity includes prompts for related questions, which makes navigating a new topic much easier.


Incognito mode: Like most browsers, Perplexity offers an incognito mode. I haven’t used it yet, but it’s a nice feature.


Language flexibility: If you write in a certain language, you’ll get sources in that language. This is a standard approach for browsers but not always convenient. For a while, I continued using the free version, but recently I switched to Pro. The free version uses the GPT-3.5 model, whereas the Pro plan grants access to the latest models: GPT-4 Omni, Claude-3 Sonnet/Opus, and Sonar Large 32k, so all the best features are integrated into your search. Of course, the Pro version offers better, smarter, and faster search. In addition to the features mentioned above, here’s what I found most useful: Broaden your search with images: Pro provides access to Playground V2.5, DALLE 3, and Stable Diffusion XL models that can expand your search. For example, I was recently researching fund flow modeling, and having visual examples was incredibly helpful.


Files, code, and more input options: You can upload unlimited files, code, pictures, etc. It’s really fast and much more convenient than doing this through a standard browser because it’s all in one space with seamless AI interaction. ChatGPT Search This feature was launched in October 2024 and is based on GPT-4o, specifically trained for search. It’s integrated into ChatGPT, allowing you to enable it with a Search button or simply ask ChatGPT to search the web. As I mentioned, I’ve been a long-time user of ChatGPT for several years, so I seamlessly integrated the search feature into my routine. Since free Perplexity uses GPT-3.5, all its features like AI search with no ads, no endless scrolling, and results organized into threads with helpful tips are available here as well. My favorite feature here is its accessibility, offering text-to-speech, and the ability to create queries via audio, and audio dialogs. Choose your fighter Search Quality Perplexity excels at finding information, while ChatGPT Search is better at explaining it. From a user perspective, I wouldn’t say I’ve encountered any critical issues with not finding something. It’s just a matter of different approaches. Perplexity provides more an overview of sources, whereas ChatGPT tends to give more explanation than summary. Generated Answers Without Sources Both tools provide sources for their answers, but sometimes the information might be generated without a reliable link. Even when a link is provided, the relevant information might not actually be there. It’s always better to double-check and read the sources yourself. Based on my experience, ChatGPT is more prone to generating unsupported content than Perplexity, but I’ve encountered this issue in both tools. Search Speed I didn’t notice a significant difference between the two in terms of speed. However, both are slower than a standard browser search. Chrome extensions Both tools offer Chrome extensions, and I tested both. The ChatGPT extension lets you use ChatGPT as your primary search engine, replacing, for example, Google. When you enter something in the search bar, it redirects you to ChatGPT, where your query is processed. Honestly, I wasn’t a fan. It’s slower than Google, and you can feel it. I still prefer a traditional search bar for quick lookups. Perplexity’s Chrome extension works differently. Instead of replacing your search engine, it opens a small window over the current page, allowing you to googling and query Perplexity simultaneously. I really loved this one, because it’s more useful for me. The drawback is that you can only enter one query at a time, and if you want to continue the conversation, it redirects you to a separate Perplexity tab. Unique Features Since both tools use GPT models, they share many great features. Perplexity Pro stands out with its use of multiple models and built-in illustrations. On the other hand, I really appreciate ChatGPT’s accessibility and seamless integration into its apps, which I use for more than just search. Bonus: Hangman game test I saw a funny tweet claiming ChatGPT can’t play Hangman. Turns out, neither can Perplexity Pro, even with all its models. Final Take: Which Works Best for What To start with, I’m a fan of AI search. Usually, it takes longer than quick googling, so here’s how I see it: if I need a super quick answer from the first link, I’ll use a standard browser search. But if I need to find more information or conduct deeper research, AI search is the way to go. It’s the best method to uncover valuable insights more efficiently. As for ChatGPT Search and Perplexity, in my experience, they solve different problems. ChatGPT Search perfectly extends ChatGPT’s capabilities, given that ChatGPT’s knowledge base only goes up to the year 2021. It’s perfect for studying and gaining insights using up-to-date web information. Perplexity, on the other hand, is better for finding something more thoroughly. It takes more from browser search, like incognito pages, and its approach to work with your prompts. It is about searching for information first and explaining second, in contrast to ChatGPT Search. For me: Need to find something? Perplexity.
Need to understand something? ChatGPT + Search. They complement each other perfectly in work. Optimizing workflows with AI has become a game-changer for me, especially when it comes to searching for information. For a while, I relied on the free version of Perplexity , but recently, I upgraded to Perplexity Pro . Meanwhile, as a longtime user of ChatGPT , I’ve also been exploring its new ChatGPT Search feature. In this article, I’ll share my experiences with both tools, compare their strengths and weaknesses, and help you decide which one might be the better fit for your needs. Perplexity Perplexity Pro ChatGPT ChatGPT Search Perplexity I’d heard about Perplexity.ai many times, promised myself I’d try it, and eventually did, but it didn’t quite click. It’s hard to fully appreciate a tool until you use it regularly. I forgot about it until I got a test assignment for a job interview in a new field, requiring tons of research. Honestly, I’m not great at googling. But since I frequently use ChatGPT and have gotten pretty good at writing prompts, I thought of giving Perplexity another shot. This was before the release of ChatGPT Search, and at that point, I’d already maxed out what ChatGPT could offer. Perplexity turned out to be a lifesaver. It made long, tedious searches much quicker and was my first truly game-changing experience with AI search. Perplexity.ai At the time, I used the free version. Compared to browser searches, here’s what I found more convenient in AI search: Fewer distractions from ads: Most browsers put ads at the top, so you have to scroll past them just to get to the first actual search result. Even without the ads, the top links are often not very relevant, and there are still too many to sift through. This makes it easy to lose motivation to click beyond the first couple of pages. AI does all that for you, providing a list of sources you can explore further on your own. Threaded searches with context: I loved how searches are organized into threads, preserving context. For my test assignment, since I was learning a new field from scratch, one question would lead to many others. It was convenient to continue and expand the search without starting over each time. If I remembered something later, I could easily return to a specific thread and pick up where I left off. Helpful question suggestions: Each thread in Perplexity includes prompts for related questions, which makes navigating a new topic much easier. Incognito mode: Like most browsers, Perplexity offers an incognito mode. I haven’t used it yet, but it’s a nice feature. Language flexibility: If you write in a certain language, you’ll get sources in that language. This is a standard approach for browsers but not always convenient. Fewer distractions from ads: Most browsers put ads at the top, so you have to scroll past them just to get to the first actual search result. Even without the ads, the top links are often not very relevant, and there are still too many to sift through. This makes it easy to lose motivation to click beyond the first couple of pages. AI does all that for you, providing a list of sources you can explore further on your own. Fewer distractions from ads: Most browsers put ads at the top, so you have to scroll past them just to get to the first actual search result. Even without the ads, the top links are often not very relevant, and there are still too many to sift through. This makes it easy to lose motivation to click beyond the first couple of pages. AI does all that for you, providing a list of sources you can explore further on your own. Fewer distractions from ads: Threaded searches with context: I loved how searches are organized into threads, preserving context. For my test assignment, since I was learning a new field from scratch, one question would lead to many others. It was convenient to continue and expand the search without starting over each time. If I remembered something later, I could easily return to a specific thread and pick up where I left off. Threaded searches with context: I loved how searches are organized into threads, preserving context. For my test assignment, since I was learning a new field from scratch, one question would lead to many others. It was convenient to continue and expand the search without starting over each time. If I remembered something later, I could easily return to a specific thread and pick up where I left off. Threaded searches with context: Helpful question suggestions: Each thread in Perplexity includes prompts for related questions, which makes navigating a new topic much easier. Helpful question suggestions: Each thread in Perplexity includes prompts for related questions, which makes navigating a new topic much easier. Helpful question suggestions: Incognito mode: Like most browsers, Perplexity offers an incognito mode. I haven’t used it yet, but it’s a nice feature. Incognito mode: Like most browsers, Perplexity offers an incognito mode. I haven’t used it yet, but it’s a nice feature. Incognito mode: Language flexibility: If you write in a certain language, you’ll get sources in that language. This is a standard approach for browsers but not always convenient. Language flexibility: If you write in a certain language, you’ll get sources in that language. This is a standard approach for browsers but not always convenient. Language flexibility: For a while, I continued using the free version, but recently I switched to Pro . The free version uses the GPT-3.5 model, whereas the Pro plan grants access to the latest models: GPT-4 Omni, Claude-3 Sonnet/Opus, and Sonar Large 32k, so all the best features are integrated into your search. Of course, the Pro version offers better, smarter, and faster search. Pro In addition to the features mentioned above, here’s what I found most useful: In addition to the features mentioned above, here’s what I found most useful: Broaden your search with images: Pro provides access to Playground V2.5, DALLE 3, and Stable Diffusion XL models that can expand your search. For example, I was recently researching fund flow modeling, and having visual examples was incredibly helpful. Files, code, and more input options: You can upload unlimited files, code, pictures, etc. It’s really fast and much more convenient than doing this through a standard browser because it’s all in one space with seamless AI interaction. Broaden your search with images: Pro provides access to Playground V2.5, DALLE 3, and Stable Diffusion XL models that can expand your search. For example, I was recently researching fund flow modeling, and having visual examples was incredibly helpful. Broaden your search with images: Pro provides access to Playground V2.5, DALLE 3, and Stable Diffusion XL models that can expand your search. For example, I was recently researching fund flow modeling, and having visual examples was incredibly helpful. Broaden your search with images: Files, code, and more input options: You can upload unlimited files, code, pictures, etc. It’s really fast and much more convenient than doing this through a standard browser because it’s all in one space with seamless AI interaction. Files, code, and more input options: You can upload unlimited files, code, pictures, etc. It’s really fast and much more convenient than doing this through a standard browser because it’s all in one space with seamless AI interaction. Files, code, and more input options: ChatGPT Search ChatGPT Search This feature was launched in October 2024 and is based on GPT-4o, specifically trained for search. It’s integrated into ChatGPT , allowing you to enable it with a Search button or simply ask ChatGPT to search the web. ChatGPT As I mentioned, I’ve been a long-time user of ChatGPT for several years, so I seamlessly integrated the search feature into my routine. Since free Perplexity uses GPT-3.5, all its features like AI search with no ads, no endless scrolling, and results organized into threads with helpful tips are available here as well. My favorite feature here is its accessibility, offering text-to-speech, and the ability to create queries via audio, and audio dialogs. Choose your fighter Search Quality Search Quality Search Quality Search Quality Perplexity excels at finding information, while ChatGPT Search is better at explaining it. From a user perspective, I wouldn’t say I’ve encountered any critical issues with not finding something. It’s just a matter of different approaches. Perplexity provides more an overview of sources, whereas ChatGPT tends to give more explanation than summary. overview explanation Generated Answers Without Sources Generated Answers Without Sources Generated Answers Without Sources Generated Answers Without Sources Both tools provide sources for their answers, but sometimes the information might be generated without a reliable link. Even when a link is provided, the relevant information might not actually be there. It’s always better to double-check and read the sources yourself. Based on my experience, ChatGPT is more prone to generating unsupported content than Perplexity, but I’ve encountered this issue in both tools. Search Speed Search Speed Search Speed Search Speed I didn’t notice a significant difference between the two in terms of speed. However, both are slower than a standard browser search. Chrome extensions Chrome extensions Chrome extensions Chrome extensions Both tools offer Chrome extensions, and I tested both. The ChatGPT extension lets you use ChatGPT as your primary search engine, replacing, for example, Google. When you enter something in the search bar, it redirects you to ChatGPT, where your query is processed. Honestly, I wasn’t a fan. It’s slower than Google, and you can feel it. I still prefer a traditional search bar for quick lookups. Perplexity’s Chrome extension works differently. Instead of replacing your search engine, it opens a small window over the current page, allowing you to googling and query Perplexity simultaneously. I really loved this one, because it’s more useful for me. The drawback is that you can only enter one query at a time, and if you want to continue the conversation, it redirects you to a separate Perplexity tab. Unique Features Unique Features Unique Features Unique Features Since both tools use GPT models, they share many great features. Perplexity Pro stands out with its use of multiple models and built-in illustrations. On the other hand, I really appreciate ChatGPT’s accessibility and seamless integration into its apps, which I use for more than just search. Bonus: Hangman game test Bonus: Hangman game test Bonus: Hangman game test Bonus: Hangman game test I saw a funny tweet claiming ChatGPT can’t play Hangman. Turns out, neither can Perplexity Pro, even with all its models. Final Take: Which Works Best for What To start with, I’m a fan of AI search. Usually, it takes longer than quick googling, so here’s how I see it: if I need a super quick answer from the first link, I’ll use a standard browser search. But if I need to find more information or conduct deeper research, AI search is the way to go. It’s the best method to uncover valuable insights more efficiently. As for ChatGPT Search and Perplexity, in my experience, they solve different problems. ChatGPT Search perfectly extends ChatGPT’s capabilities, given that ChatGPT’s knowledge base only goes up to the year 2021. It’s perfect for studying and gaining insights using up-to-date web information. Perplexity, on the other hand, is better for finding something more thoroughly. It takes more from browser search, like incognito pages, and its approach to work with your prompts. It is about searching for information first and explaining second, in contrast to ChatGPT Search. For me: For me: Need to find something? Perplexity. Need to understand something? ChatGPT + Search. Need to find something? Perplexity. Need to find something? Need to understand something? ChatGPT + Search. Need to understand something? They complement each other perfectly in work.

Perplexity Pro vs. ChatGPT Search: Which AI Tool is Best Fits Your Workflow Needs?

Perplexity супраць пошуку ChatGPT: які інструмент AI лепш за ўсё адпавядае вашым патрэбам працоўнага працэсу?

Perplexity срещу ChatGPT Search: Кой AI инструмент отговаря най-добре на вашите нужди от работен процес?

Perplexity vs. Búsqueda en ChatGPT: ¿Qué herramienta de IA se adapta mejor a sus necesidades de flujo de trabajo?

Շփոթմունքն ընդդեմ ChatGPT որոնման. Ո՞ր AI գործիքն է լավագույնս համապատասխանում ձեր աշխատանքային հոսքի կարիքներին:

Perplexity と ChatGPT Search: どちらの AI ツールがワークフローのニーズに最適ですか?

ភាពច្របូកច្របល់ធៀបនឹងការស្វែងរក ChatGPT៖ តើឧបករណ៍ AI មួយណាដែលសាកសមបំផុតនឹងតម្រូវការលំហូរការងាររបស់អ្នក?

Perplexity vs. ChatGPT paieška: kuris AI įrankis geriausiai atitinka jūsų darbo eigos poreikius?

Fikarohana ChatGPT: Inona no fitaovana AI mifanaraka amin'ny filanao?

Збунетост наспроти Пребарување ChatGPT: која алатка за вештачка интелигенција најдобро одговара на вашите потреби на работниот тек?

Urujijo na ChatGPT Gushakisha: Niki Gikoresho cya AI gihuye neza nakazi kawe gakenewe?

குழப்பம் மற்றும் ChatGPT தேடல்: எந்த AI கருவி உங்கள் பணிப்பாய்வு தேவைகளுக்கு மிகவும் பொருத்தமானது?

Perplexity กับ ChatGPT Search: เครื่องมือ AI ตัวใดที่เหมาะกับความต้องการเวิร์กโฟลว์ของคุณที่สุด

How to Build a Turing Pi 2 Home Cluster

Як пабудаваць хатні кластар Turing Pi 2

Kako napraviti Turing Pi 2 kućni klaster

Cómo construir un clúster doméstico de Turing Pi 2

Kuinka rakentaa Turing Pi 2 -kotiklusteri

Come costruire un cluster domestico Turing Pi 2

Turing Pi 2 ホームクラスターの構築方法

របៀបបង្កើតចង្កោមផ្ទះ Turing Pi 2

Turing Pi 2 гэрийн кластерийг хэрхэн бүтээх вэ

څنګه د ټورینګ پای 2 کور کلستر جوړ کړئ

Maitiro ekugadzira Turing Pi 2 Kumba Cluster

Ndlela Yo Aka Xirhendzevutani Xa le Kaya xa Turing Pi 2

如何构建 Turing Pi 2 家庭集群

This is a no-fluff list of the tools we're using at the startup I work at (making $100k/mo). At this stage, it’s tempting to subscribe to every premium tool, but we stick to a guiding principle: keep it simple, maximize value, and avoid overcomplication. Here’s what works for us: Version Control System - GitHub We use GitHub for version control because it’s an industry standard with excellent integrations. It helps us manage our repositories and work collaboratively with a familiar interface. Team Communication - Slack Slack is our go-to communication tool. It allows us to create channels, communicate asynchronously, and quickly solve blockers. The integrations with other tools, like GitHub and Google Calendar, help us centralize notifications and keep conversations organized. Code Review Tool - PullNotifier PullNotifier increases visibility for code reviews, which is crucial for our team. It sends real-time notifications to Slack whenever a pull request is opened, helping us streamline the review process and ensure faster iterations. Project Management - Jira Jira keeps our project management on track. It's flexible, allows us to manage sprints, and track the progress of tasks easily. The integration with GitHub makes it easy to sync code progress with project management. CI/CD - GitHub Actions GitHub Actions powers our continuous integration and deployment. Since it's built into GitHub, it’s easy to set up, automate tests, and deploy code without switching platforms. It simplifies the process and saves time. Documentation and Internal Notes - Confluence Confluence is our go-to for internal documentation. It’s perfect for keeping all our notes, wikis, and processes in one place. Plus, its integration with Jira makes referencing project updates smooth. Accounting, Payments & Employee Management - Xero Xero handles our accounting and payroll. It’s simple, effective, and automates much of the tedious financial work. The real-time financial reporting is invaluable for managing cash flow. Infrastructure Platform - AWS AWS gives us the scalability and reliability we need for hosting our apps. With services like ECS and RDS, we can easily manage our infrastructure while controlling costs. Error Reporting, Logging, and Internal Dashboards - NewRelic NewRelic helps us monitor application performance and log errors in real-time. It provides detailed insights, which allows us to troubleshoot issues quickly and keep our platform stable. Email Provider - Google Google Workspace handles our email needs, and its reliability and integration with other tools, like Google Calendar, make it an easy choice for seamless communication. Meetings - Google Calendar and Slack Huddles We rely on Google Calendar for scheduling meetings and Slack Huddles for quick, impromptu discussions. These tools keep our meetings short and efficient. Code Quality - SonarCloud SonarCloud provides automatic code analysis and ensures that we maintain a high standard for code quality. It helps us detect bugs and security vulnerabilities before they become issues. Server Uptime Monitoring - Healthchecks.io Healthchecks.io keeps track of our cron jobs and scheduled tasks. It sends alerts if something goes wrong, ensuring we’re always on top of potential downtime issues. These tools have been chosen because they offer the best value for our needs, helping us stay lean and focused as we continue to grow. Do you have anything to add to this list? This is a no-fluff list of the tools we're using at the startup I work at (making $100k/mo). At this stage, it’s tempting to subscribe to every premium tool, but we stick to a guiding principle: keep it simple, maximize value, and avoid overcomplication . keep it simple, maximize value, and avoid overcomplication Here’s what works for us: Version Control System - GitHub GitHub GitHub We use GitHub for version control because it’s an industry standard with excellent integrations. It helps us manage our repositories and work collaboratively with a familiar interface. Team Communication - Slack Slack Slack Slack is our go-to communication tool. It allows us to create channels, communicate asynchronously, and quickly solve blockers. The integrations with other tools, like GitHub and Google Calendar, help us centralize notifications and keep conversations organized. Code Review Tool - PullNotifier PullNotifier PullNotifier PullNotifier increases visibility for code reviews, which is crucial for our team. It sends real-time notifications to Slack whenever a pull request is opened, helping us streamline the review process and ensure faster iterations. Project Management - Jira Jira Jira Jira keeps our project management on track. It's flexible, allows us to manage sprints, and track the progress of tasks easily. The integration with GitHub makes it easy to sync code progress with project management. CI/CD - GitHub Actions GitHub Actions GitHub Actions GitHub Actions powers our continuous integration and deployment. Since it's built into GitHub, it’s easy to set up, automate tests, and deploy code without switching platforms. It simplifies the process and saves time. Documentation and Internal Notes - Confluence Confluence Confluence Confluence is our go-to for internal documentation. It’s perfect for keeping all our notes, wikis, and processes in one place. Plus, its integration with Jira makes referencing project updates smooth. Accounting, Payments & Employee Management - Xero Xero Xero Xero handles our accounting and payroll. It’s simple, effective, and automates much of the tedious financial work. The real-time financial reporting is invaluable for managing cash flow. Infrastructure Platform - AWS AWS AWS AWS gives us the scalability and reliability we need for hosting our apps. With services like ECS and RDS, we can easily manage our infrastructure while controlling costs. Error Reporting, Logging, and Internal Dashboards - NewRelic NewRelic NewRelic NewRelic helps us monitor application performance and log errors in real-time. It provides detailed insights, which allows us to troubleshoot issues quickly and keep our platform stable. Email Provider - Google Google Google Google Workspace handles our email needs, and its reliability and integration with other tools, like Google Calendar, make it an easy choice for seamless communication. Meetings - Google Calendar and Slack Huddles Google Calendar and Slack Huddles We rely on Google Calendar for scheduling meetings and Slack Huddles for quick, impromptu discussions. These tools keep our meetings short and efficient. Code Quality - SonarCloud SonarCloud SonarCloud SonarCloud provides automatic code analysis and ensures that we maintain a high standard for code quality. It helps us detect bugs and security vulnerabilities before they become issues. Server Uptime Monitoring - Healthchecks.io Healthchecks.io Healthchecks.io Healthchecks.io keeps track of our cron jobs and scheduled tasks. It sends alerts if something goes wrong, ensuring we’re always on top of potential downtime issues. These tools have been chosen because they offer the best value for our needs, helping us stay lean and focused as we continue to grow. Do you have anything to add to this list?

Tools That Keep Our $100k/mo Startup Running

Stories, News & Mentions about SONAR

Sonar’s Stories on HackerNoon

Sonar's News & Mentions