[108 Pages Report] Global Sulphur Fungicides Market report is a comprehensive analysis of the industry, market, and key players. The report has covered the market by demand and supply-side by ...

Sulphur Fungicides Market's Growth Potential & Predicted Landscape from 2023 to 2031

The top three suppliers remained unchanged from the previous year, with NovaSource leading, followed by SOLV Energy, and Spain's Solarig in third place. Across the portfolios analyzed by Wood ...

US solar O&M contract prices averaged $7.90/kW in 2022, says WoodMac

but the BBB makes a note on its page that “based on BBB files this company has a pattern of complaints.” The attorneys general in many states have sued companies that they say targeted vulnerable populations and misrepresented the benefits of rooftop ...

Rooftop Solar Power Has a Dark Side

But for a business as large as Nestlé, it's entirely possible that those billions are just drops in the bucket. So does its biotech work make this stock worth buying, or is it just an oddity created as a long shot attempt to drive growth? To answer this question, let's start by putting the issue into the proper context.

Does Nestlé's Biotech Segment Make It a Buy?

The combined company will perform aerial inspection on over 170 GW of solar this year. Previously a division of NovaSource Power Services, Heliolytics brings a suite of robust solar inspection diagnostic and analytic capabilities to further Zeitview's ...

Zeitview Acquires Heliolytics, Becoming the Market Leader in Solar Aerial Inspections

The acquisition of this former division of NovaSource Power Services enables the combining of Heliolytics’ data insights with Zeitview’s capabilities in aerial inspection technologies. The majority of Heliolytics staff will join Zeitview, and the team ...

Zeitview acquires Heliolytics, expanding aerial solar inspections

Previously a division of NovaSource Power Services, Heliolytics brings a suite of robust solar inspection diagnostic and analytic capabilities to further Zeitview’s advanced energy and ...

NovoSource

novosource

Testing ICP Face Recognition DApp: The Final Result Will Surprise You

اختبار تطبيق التعرف على الوجه ICP: النتيجة النهائية سوف تفاجئك

Тестване на ICP Face Recognition DApp: Крайният резултат ще ви изненада

Testiranje ICP aplikacije za prepoznavanje lica: Konačni rezultat će vas iznenaditi

Prueba de la aplicación de reconocimiento facial ICP: el resultado final te sorprenderá

Az ICP arcfelismerő DApp tesztelése: A végeredmény meg fogja lepni

ICP 顔認識 DApp のテスト: 最終結果に驚く

ICP სახის ამოცნობის DApp ტესტირება: საბოლოო შედეგი გაგაოცებთ

ICP Face Recognition DApp сынағы: соңғы нәтиже сізді таң қалдырады

Fitsapana ICP Face Recognition DApp: Hahagaga anao ny vokatra farany

Menguji DApp Pengecaman Wajah ICP: Keputusan Akhir Akan Mengejutkan Anda

ICP Uya riqsiyta prueba DApp: Qhipa ruwayqa musphachisunki

Ukuhlola I-ICP Face Recognition DApp: Umphumela Wokugcina Uzokumangaza

A Simplified Guide for the"Dockerazition" of Ruby and Rails With React Front-End App 

রিঅ্যাক্ট ফ্রন্ট-এন্ড অ্যাপ সহ রুবি এবং রেলের "ডকেরাজিশন" এর জন্য একটি সরলীকৃত গাইড 

Eine vereinfachte Anleitung zur „Dockerazition“ von Ruby und Rails mit der React Front-End-App

Una guía simplificada para la "Dockerazition" de Ruby y Rails con la aplicación React Front-End 

Un guide simplifié pour la « Dockerazition » de Ruby et Rails avec l'application React Front-End 

रिएक्ट फ्रंट-एंड ऐप के साथ रूबी और रेल्स के "डॉकराज़िशन" के लिए एक सरलीकृत गाइड

React フロントエンド アプリを使用した Ruby と Rails の「Docker 化」の簡易ガイド

React 프런트엔드 앱을 사용한 Ruby 및 Rails의 "Dockerazition"에 대한 단순화된 가이드 

Um guia simplificado para o "Dockerazition" de Ruby e Rails com o aplicativo React Front-End 

Упрощенное руководство по «докеразии» Ruby и Rails с помощью внешнего приложения React 

React Front-End Uygulaması ile Ruby ve Rails'in "Dockerazition"u için Basitleştirilmiş Bir Kılavuz 

Hướng dẫn đơn giản hóa về "Dockerazition" của Ruby và Rails với ứng dụng React Front-End 

使用 React 前端应用程序对 Ruby 和 Rails 进行“Dockerazition”的简化指南

How We Enhanced Remotion Performance through GPU-Accelerated Server-Side Rendering Running with hardware acceleration in headless mode can be more challenging than it appears. We embarked on this journey with , which is an excellent framework that enables developers to "Make Videos Programmatically.” On our way, explore various Nvidia driver versions, including those from Nvidia's website and Ubuntu's official repositories. Google Chrome Remotion We collaborated with the vibrant Open-source community to find the answer for using . After encountering some setbacks on our way, we were able to make it work for Remotion eventually. We consolidated our findings in the Remotion Docs at and simplified the instructions for Remotion developers to make the most out of it. Although the whole research was done for , the same process will work for any headless application that requires GPU power, especially in headless mode. Remotion GPU with Remotion for server-side rendering Using the GPU in the Cloud Remotion Hardware Acceleration in Browser Rendering Hardware Acceleration is to your browser what " " is for a gasoline car. It uses the power of specialized hardware like GPUs to make your web pages load faster, and videos play smoothly. Hardware acceleration improves the part where the web page is displayed and shown to you, known as rendering. This results in a smoother and snappier browsing experience. Nitrogen Fuel DLAMI from Marketplace? One may wonder why we didn't opt for the AWS Deep Learning AMI or DLAMI. But we needed fine-grained control over the GPU drivers and utilities and the outdated DLAMIs despite all the bloatware was not the answer. Such tasks are often challenging to achieve with pre-packaged AMIs, as discussed in " .” Tailoring the environment to our exact requirements also helped us troubleshoot issues effectively. Why Deep Learning AMI is Holding You Back We experimented with multiple packages to identify the key ones needed for Google Chrome to recognize the GPU. Despite these efforts, GPU recognition remained elusive, and in some instances, GPU drivers were crashing even at initialization. The long and arduous journey has brought us to the end of the tunnel, yet the darkness persists, and the solution remains as elusive as ever. As we decided to call it a day, We stumbled upon on 's Github issues, which did not give us any hope but did give us a new perspective and drive to achieve our goal. this thread Puppeteer The Fresh Start It was time to return to the drawing board and start afresh. We started with a clean base Ubuntu AMI on AWS EC2 Instance. After that, we downloaded and installed the Nvidia Tesla T4G drivers from Nvidia's official website. Once it was confirmed that the GPU was working properly using , we installed Google Chrome and tested it for hardware acceleration. To our relief, Google Chrome finally gave a nod to work with Hardware Acceleration. nvidia-smi Launching an EC2 Instance Launching an EC2 instance can be achieved in various ways, with the AWS Web Console and AWS CLI being two notable options. Regardless of the method, the important parameters are instance type and AMI selection. At the time of writing, the AMI ID for our chosen instance is . For launching the EC2 instance via , the following command can be used after replacing the placeholders with actual values. g4dn.xlarge ami-053b0d53c279acc90 aws-cli aws ec2 run-instances \
  --instance-initiated-shutdown-behavior "terminate" \
  --image-id "ami-053b0d53c279acc90" \
  --instance-type "g4dn.xlarge" \
  --key-name "<KEY_NAME>" \
  --subnet-id "<SUBNET_ID>" \
  --security-group-ids "<SECURITY_GROUP_ID>" \
  --iam-instance-profile Arn="<ARN>" \
  --block-device-mappings '[
  {
    "DeviceName": "/dev/sda1",
    "Ebs": {
      "VolumeSize": 8,
      "VolumeType": "gp3"
    }
  }
]' Ubuntu and Kernel Upgrade Ubuntu 22.04 AMI on AWS comes with Linux Kernel (specifically ). At this point, we have two options either we stick with Kernel or Upgrade to ( ), we decided to upgrade the Kernel. This decision is crucial as the Nvidia driver compiled for one version will not work for the other. ami-053b0d53c279acc90 v5 5.19.0-1025-aws v5 v6 v6.2.0-1013-aws After launching the instance, SSH into the instance and initiate the Ubuntu packages upgrade process. To update all the installed packages, including Linux Kernel, execute the following one-liner. sudo bash -c "apt update && export DEBIAN_FRONTEND=noninteractive && export NEEDRESTART_MODE=a && apt upgrade -y && reboot" We can also split , and . But the reason behind doing it like this is to install these updates in non-interactive mode. apt update apt upgrade -y reboot After the execution, the system will reboot with Linux Kernel Version 6. We can confirm the kernel update with . Rebooting is essential when upgrading the Ubuntu system because it loads the new Kernel on the next boot, and Nvidia drivers will subsequently be built for the updated version. uname -r Nvidia GPU Driver Installation The process of installing GPU drivers is straightforward when we have the correct driver for the GPU and the corresponding compatible version. Before starting the installation, we need to install a couple of packages: and . The former is a bundle with a variety of compilation tools required to compile the Nvidia driver. The latter, while not mandatory, is required by Google Chrome. Therefore, it's a good idea to install it beforehand to enable support for Vulkan ICD loader for Nvidia, should we require it in the future. build-essential libvulkan1 sudo apt install -y build-essential libvulkan1 After build tools are installed, we can proceed to download and install the GPU drivers using the following commands: DRIVER_URL="https://us.download.nvidia.com/tesla/535.104.12/NVIDIA-Linux-x86_64-535.104.12.run"
DRIVER_NAME="NVIDIA-Linux-driver.run"
wget -O "$DRIVER_NAME" "$DRIVER_URL"
sudo sh "$DRIVER_NAME" --disable-nouveau --silent
rm "$DRIVER_NAME" Now we can run to confirm the GPU driver installation. The output will look similar to this: nvidia-smi Configuring the Startup Service We learned this the hard way: running once is needed for the proper initialization of and . Google Chrome and Chromium fail to initialize without this preliminary setup. To automate this process, we will create a service that runs at boot time using the following commands: nvidia-smi EGL ANGLE EGL nvidia-smi echo '[Unit]
Description=Run nvidia-smi at system startup

[Service]
ExecStart=/usr/bin/nvidia-smi
Type=oneshot
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target' | sudo tee /etc/systemd/system/nvidia-smi.service
sudo systemctl enable nvidia-smi.service
sudo systemctl start nvidia-smi.service Testing the Installation To test hardware acceleration with Google Chrome or Chromium, we can follow these steps. It's worth noting that Google Chrome has more dependencies, making it an easier choice if we plan to use the Node.js library, Puppeteer. On the other hand, Chromium is a lightweight option with a smaller footprint of dependencies, but we can still use Puppeteer with Chromium by installing a few extra dependencies. Installing Chromium Installation Installing Chromium is straightforward, as it is readily available with Ubuntu's official software repositories. We can install it using with the following command. apt sudo apt install -y chromium-browser Testing Chromium is fully prepared to handle Hardware Acceleration tasks. We can verify its readiness by launching Chromium with the specified parameters. chromium-browser --headless --use-gl=angle \
   --use-angle=gl-egl --use-cmd-decoder=passthrough \
   --print-to-pdf=output.pdf 'chrome://gpu' Installing Puppeteer Dependencies To use Puppeteer with Chromium instead of Google Chrome, there are a few extra dependencies that should be installed. sudo apt install ca-certificates fonts-liberation \
    libasound2 libatk-bridge2.0-0 libatk1.0-0 libc6 \
    libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 \
    libgbm1 libgcc1 libglib2.0-0 libgtk-3-0 libnspr4 libnss3 \
    libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 \
    libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 \
    libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 \
    libxtst6 lsb-release wget xdg-utils Installing Google Chrome Installation Google Chrome can be installed from multiple options, but we will use the Google Chrome official repository for Debian. We need to add it to Ubuntu's repo list along with the public signing key. curl -fsSL https://dl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor -o /usr/share/keyrings/googlechrom-keyring.gpg
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/googlechrom-keyring.gpg] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google-chrome.list
sudo apt update
sudo apt install -y google-chrome-stable Testing Google Chrome is ready for our Hardware Acceleration tasks. We can test it by launching Google Chrome with the following parameters. google-chrome-stable --headless --use-gl=angle \
    --use-angle=gl-egl --use-cmd-decoder=passthrough \
    --print-to-pdf=output.pdf 'chrome://gpu' The above commands will generate , and transfer it to your local machine to check the status of Hardware Acceleration in Google Chrome or Chromium. If the process goes smoothly, the resultant will look like this. output.pdf PDF Working with Puppeteer To verify GPU acceleration using the Node.js library Puppeteer, follow these steps: Installation Install Node.js, as this clean Ubuntu AMI does not include any unnecessary packages. Use the following commands: curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
NODE_MAJOR=18
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list
sudo apt update
sudo apt install nodejs Testing After installing Node.js, we can install Puppeteer by running in our code directory. Here's a sample file for checking hardware acceleration: npm i puppeteer index.js const puppeteer = require('puppeteer');
(async () => {
  const browser = await puppeteer.launch({
    headless: true, 
    args: ['--use-gl=angle', '--use-angle=gl-egl'], 
  });
  const page = await browser.newPage();
  await page.goto('chrome://gpu');
  await page.waitForTimeout(2000);
  await page.screenshot({ path: 'output.png' });
  await browser.close();
})(); Run the script using . This will generate an file containing hardware acceleration information. node index.js output.png Note from the Creator has been immensely helpful in helping the “ ” community adopt GPU-accelerated rendering.He's researched and written about how to obtain, configure and run EC2 containers and headless Chrome correctly in order to take advantage of graphics acceleration.This area has been especially hard to crack, and without we would not have been able to unlock huge speed boosts. Mirza Remotion Mirza We are super grateful for that! -- Jonny Burger Creator / Remotion.dev Conclusion With hardware acceleration now readily available in headless mode, we can harness the power of GPUs for faster and more complex rendering tasks. Our next steps involve creating a custom AMI from this instance and streamlining the process using AWS Image Builder Pipelines for efficiency. Additionally, we plan to extend hardware capabilities to Docker containers, further extending our options. Resources Remotion - Make videos programmatically: https://remotion.dev Remotion - Using the GPU in the cloud: https://www.remotion.dev/docs/miscellaneous/cloud-gpu Cannot enable GPU acceleration: github.com/puppeteer/puppeteer/issues/3637 : Recommend a workflow for using the GPU on a AWS instance https://github.com/remotion-dev/remotion/issues/2889 Getting Started with Headless Chrome: developer.chrome.com/blog/headless-chrome Why Your AWS Deep Learning AMI is Holding You Back and How to Fix: mirzabilal.com/why-your-aws-deep-learning-a.. Deep Learning with “AWS Graviton2 + NVIDIA Tensor T4G” for as low as free* with CUDA 12.2: mirzabilal.com/deep-learning-with-aws-gravi.. How to install FFmpeg with Harware Accelaration on AWS: mirzabilal.com/how-to-install-ffmpeg-with-h.. CPU vs GPU for Video Transcoding - Challenging the Cost-Speed Myth: https://mirzabilal.com/cpu-vs-gpu-for-video-transcoding-challenging-the-cost-speed-myth Also published . here

Unlocking GPU-Accelerated Server-Side Rendering in Remotion With Chrome, Chromium & Puppeteer

When you’re getting started with Docker, it is important to understand what is a Dockerfile. You will work with Dockerfiles in every project you work on regardless of the operating system you’re using in your image. If you want to follow along with the demos in this blog post, you will need the food trucks’ repo from the Docker community repos. You can find it on their . GitHub https://youtu.be/DqyNssbqEaE?embedable=true A Dockerfile is similar to a batch script that contains all the commands to build a . The first line states that the base image is to begin with, and then follow the instructions to install required modules, copy files, and deploy the code which results in a working environment. Docker image Every Dockerfile must start with the FROM instruction. This tells Docker what base image to use as you build your final image. In this case, we are using the ubuntu standard OS image. You can find images for many different operating systems and development environments for any technology you’re using. The LABEL instruction adds metadata to an image. A LABEL is a key-value pair. You can add multiple labels to a Dockerfile to include any custom information you want. In this example, we are creating a key named “maintainer” and setting it equal to the text on the right. Labels are visible when you use a docker inspect command to view low-level information on Docker objects which is helpful to keep your projects organized. LABEL maintainer="Prakhar Srivastav <[email protected]>" The RUN instruction will execute any commands in a new layer on top of the current image and commit the results. The resulting committed image will be used for the next step in the Dockerfile. All instructions are executed in order so you have to be careful to add your run instructions in the exact order they should be run. In this example, we are installing the required system-wide dependencies for Python and node as these are needed to run the food trucks website. # install system-wide deps for python and node
RUN apt-get -yqq update
RUN apt-get -yqq install python3-pip python3-dev curl gnupg
RUN curl -sL https://deb.nodesource.com/setup_10.x | bash
RUN apt-get install -yq nodejs The ADD instruction copies new files, directories, or remote file URLs from the <src> listed on the left and adds them to the filesystem of the image at the <dest> path listed on the right. The destination path is located inside the image that is being built by the Dockerfile. # copy our application code
ADD flask-app /opt/flask-app Open a terminal, execute the command and then inspect the filesystem of your container to find the destination file path. You can even save this image as a reference to use for later if you want. docker-compose up, To save an image from a running container, get the container id by typing . Then, run a command using the container id, and then, a custom image name and version. docker ps docker commit That’s it! You can run the docker images command to confirm your new image has been created. docker commit [container id] [image name]:[image version] The WORKDIR instruction sets the working directory for any RUN, CMD, ENTRYPOINT, COPY, and ADD instructions that follow it in the Dockerfile. In this example, the node package manager commands are run in the working directory that has been defined. WORKDIR /opt/flask-app

# fetch app specific deps
RUN npm install
RUN npm run build
RUN pip3 install -r requirements.txt The EXPOSE instruction informs Docker that the container listens on the specified network ports at runtime. EXPOSE does not make the ports of the container accessible to the host. # expose port
EXPOSE 5000 And finally, we have the CMD instruction. There can only be one CMD instruction in a Dockerfile. If you list more than one CMD, then only the last CMD will take effect. The main purpose of a CMD is to provide defaults for an executing container. In this example, we are running the app script for the website located in the root of the working directory and naming the app python3. # start app
CMD [ "python3", "./app.py" ] That’s it! Stop your running container by executing the command. Go back to the Dockerfile and uncomment everything using the shortcut . Save your work, and execute docker-compose down Ctrl+k+u docker-compose up. Open a browser, and navigate to localhost on port 5000. You should see the Food Trucks website! Previously published here

What Is a Dockerfile? A Quick Overview

A Complete Guide to Laravel Sail

This tutorial is intended to be a quick guide. Create a new Rails application via Docker with the following Command docker run -it ruby:3.0.2 gem install rails bundler \
  && rails new exampleapp -d=postgresql --webpack:react --skip-coffee Once the application is created, go to the application directory. All application files will be found there. cd exampleapp Create a File called Dockerfile with the Following Content // dockerfile

FROM ruby:3.0.2
RUN apt-get update -qq \
&& apt-get install -y curl build-essential libpq-dev \
 nodejs postgresql-client &&\
  curl -sL https://deb.nodesource.com/setup_10.x | bash - && \
  curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - && \
  echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list && \
  apt-get update && apt-get install -y nodejs yarn
ADD . /app
WORKDIR /app
RUN bundle install
EXPOSE 3000
CMD ["bash"] This file will help Docker Compose build an image with all the needed dependencies installed to handle Rails. It will use Postgresql as a database engine and React bundled with webpack. Create a File Called docker-compose.yml With the Following Content version: '3.8'
services:
  db:
    env_file: .env
    image: postgres
  web:
    build: .
    command: bash -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
    volumes:
      - .:/app
    ports:
      - "3000:3000"
    depends_on:
      - db
    env_file: .env
    environment:
      RAILS_ENV: development
      RAILS_MAX_THREADS: 5
volumes:
  postgres: Create a .env File Add the following environment variables. Pay special attention to the variable names since the image will need them for a proper setup, as well as the DATABASE_URL, which is needed by The query strings need to match with the other variable’s values. In the , the host is , which is the name exposed by Docker Compose. POSTGRES_ pg web. DATABASE_URL db POSTGRES_DB=postgres
POSTGRES_USER=postgres
POSTGRES_PASSWORD=secret
DATABASE_URL=postgres://postgres:secret@db:5432/postgres Edit Database.yml Edit the file and add Here is an example of a valid config file for this tutorial. Keep in mind the way you expose sensitive data and the environments you are building the Docker Compose for. config/database.yml url: <%= ENV.fetch("DATABASE_URL") { '' } %> default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  url: <%= ENV.fetch("DATABASE_URL") { '' } %> # This is the line we added
development:
  <<: *default
  database: exampleapp_development
test:
  <<: *default
  database: exampleapp_test
production:
  <<: *default
  database: exampleapp_production
  username: exampleapp
  password: <%= ENV['EXAMPLEAPP_DATABASE_PASSWORD'] %> Start the App The application is ready. We can start our application now. We are adding the parameter the first time, so that Docker Compose builds the containers first. --build docker-compose up --build Go to Localhost We can now go to in our browser. We should see the “Yay! You’re on Rails!” screen. http://localhost:3000 Now we can run commands (for example, generators and migrations) to evolve our application. We will now create a model with their controller and views, and then run a migration in this example. The model will be , and will have a name (string) and a value (float). Coin docker-compose run web rails g scaffold Coin name:string value:float \
 && rails db:migrate Here is a quick video of all that we have seen until now.

Create a Ruby on Rails (Rails-Postgresql-React) App using Docker Compose

On Linux (Ubuntu 20.04 LTS): Node Download the Node LTS archive file from and extract it (in this example, the archive is extracted in ) https://nodejs.org/ /home/user/Downloads/ Open in the home folder ( ) with a text editor, and append: .bashrc /home/user./bashrc PATH=$PATH:/home/user/Downloads/node-v14.17.0-linux-x64/bin Then, in a terminal: .bashrc

node -v npm -v source # v14.17.0 # 6.14.13 You may also need the development tools to build native addons: sudo apt install gcc g++ make Alternatively, you can install Node from a package. To install the LTS version, go to and https://github.com/nodesource/distributions # You need to install curl it if 's not already installed
sudo apt install curl

# Ubuntu
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs Yarn Install Yarn (from ) https://yarnpkg.com/getting-started/install npm install -g yarn

yarn -v # 1.22.10 Git sudo apt install git VSCode Download the .deb package from . Then, in a terminal, go to the folder, and: https://code.visualstudio.com/ Downloads sudo dpkg -i code_1.57.0-1623259737_amd64.deb code . # test it On Mac Node Download the LTS package from and install it (double click on node-v14.17.1.pkg and follow the steps). https://nodejs.org Then open a terminal, and: node -v

npm -v Yarn Open a terminal, and: npm install -g yarn

yarn -v NOTE: if you get this error: “npm WARN checkPermissions Missing write access to /usr/local/lib/node_modules/yarn” run the following commands: sudo chown -R /usr/ /lib/node_modules 
sudo chown -R /usr/ /bin
sudo chown -R /usr/ /share/ $USER local $USER local $USER local Then try to reinstall yarn with the command above. Git First, install Homebrew by following the instructions here: https://brew.sh Then, install Git with: brew install git VSCode Download the package from and install it. https://code.visualstudio.com On Windows Node Download Nodejs LTS from and install the package - don't forget to check "Automatically Install the Necessary Tools" in the installer. https://nodejs.org Then, open a terminlal (Command Prompt) and: node -v

npm -v Yarn npm install -g yarn

yarn -v Git Download the executable from here and run the installer. https://git-scm.com/download/win Then, open a terminal and: C:\Users\user>git --version
git version 2.32.0.windows.1 VSCode Download from and run the installer. VSCode https://code.visualstudio.com/ Then, to test everything, open a Command Prompt and: git https://github.com/alexadam/project-templates.git projects\react-app

yarn init --yes

yarn add react react-dom

yarn add --dev @types/react @types/react-dom ts-loader css-loader html-webpack-plugin node-sass sass-loader style-loader typescript webpack webpack-cli webpack-dev-server code . clone cd # Open VSCode Open package.json and append these lines: , : { : , : , : } "scripts" "clean" "rm -rf dist/*" "build" "webpack" "dev" "webpack serve" Run , open a browser, and go to yarn dev http://localhost:8080/ Previously published at https://alexadam.dev/blog/install-node-yarn-git.html

Quick Guide to Install Node, Yarn, Git and VSCode on Linux, Mac, and Windows

Zeet is sponsoring this blogpost for the next month. I tried it out the other day. It's like serverless but for running entire back ends. You can host and scale apps automagically. Pretty neat. Handling large images has always been a pain in my side since I started writing code. Lately, it has started to have a huge impact on page speed and SEO ranking. If your website has poorly optimized images it won’t score well on . If it doesn’t score well, it won’t be on the first page of Google. That sucks. Google Lighthouse TL;DR I’ve built and open-sourced a snippet of code that automates the process of creating and deploying an image resize function and an S3 bucket with one simple command. Check out . the code here But if you want to follow along and learn how to do it yourself, keep reading. Where do we start? Luckily enough, there is a way to solve the issue of bad image optimization with little to no hassle. Today we’ll build an function to resize images on-the-fly. AWS Lambda The images will be stored in an bucket and, once requested, will be served from it. If you need a resized version, you’ll request the image and supply the height and width. This will trigger a function. It’ll grab the existing image, resize it, return it back to the bucket and then serve it from the bucket. S3 This scenario will only resize an image for a given set of dimensions once. Every subsequent request to the image of that size will be served from the bucket. Pretty cool huh? Here’s a diagram, because who doesn’t love diagrams. Because I already assume you know how to use the and have already been introduced to the basics of , and , I’ll immediately jump into the gist of things. Here’s an overview of what we’ll be doing. Serverless Framework serverless Docker AWS Create the project structure Create a secrets file Write the AWS Lambda function configuration Write AWS Lambda function source code Write S3 Bucket configuration Deploy with DockerTest with Dashbird Note : Please install Docker and Docker Compose before continuing with this tutorial. The funny thing here is that we need to use Docker to deploy this service because of . This image-resize module has binaries that need to be built on the same operating system as it will run on. Because AWS Lambda is running on Amazon Linux, we need to the packages on an Amazon Linux instance before running . Sharp npm install sls deploy With that all out of the way let’s build some stuff. Create the project structure The best way of explaining this complex structure will be with an image. Folders in green and files in blue. Check out the for further insight. repo Create a secrets file We’ll create a secrets.env file in the folder to hold our secrets and inject them into our Docker container once it spins up. secrets SLS_KEY=XXX # replace your IAM User key 
SLS_SECRET=YYY # replace your IAM User secret 
STAGE=dev 
REGION=us-east BUCKET=images.yourdomain.com with with -1 Note : The deploy.sh script will create a secondary secrets.json file only to hold the domain name of our API Gateway endpoint. Write the AWS Lambda function configuration Open up the folder, and start by creating the file. Paste this in. functions package.json { : , : , : , : , : { : , : }
} "name" "image-resize" "version" "1.0.0" "description" "Serverless image resize on-the-fly." "main" "resize.js" "dependencies" "serverless-plugin-tracing" "^2.0.0" "sharp" "^0.18.4" No need to run any install, because we need to run the Docker container first. Note that we’re adding a tracing plugin to enable because it’s awesome. X-Ray Moving on, let’s create the file to configure our function. serverless.yml service: image-resize-on-the-fly-functions

plugins:
  - serverless-plugin-tracing

provider:
  name: aws
  runtime: nodejs8 stage: ${ :STAGE, }
  profile: serverless-admin # or change to tracing: region: ${ :REGION, }
  environment:
    BUCKET: ${ :BUCKET}
    REGION: ${ :REGION}
  iamRoleStatements:
    - Effect: Action:
        - Resource: - Effect: Action:
        - Resource: - Effect: Action:
        - - Resource:
        - functions:
  resize:
    handler: resize.handler
    events:
      - http:
          path: resize
          method: get .10 env 'dev' 'default' true env 'us-east-1' env env "Allow" "s3:ListBucket" "arn:aws:s3:::${env:BUCKET}" "Allow" "s3:PutObject" "arn:aws:s3:::${env:BUCKET}" "Allow" "xray:PutTraceSegments" "xray:PutTelemetryRecords" "*" As you can see we’re grabbing a bunch of values from the and also allowing the function to access the we specified and some X-Ray telemetry. env BUCKET Write AWS Lambda function source code Only the code left now. Here’s what we’ll do. Because images can get quite large and we don’t want to risk loading several megabytes into the lambda function’s memory, I’ll show you how to use to read the image from an S3 stream, pipe it to Sharp, and then write it back to S3, once again, as a stream. Node.js streams Ready? Let’s do it in two steps. First, define the helper functions we need in order to create the streams, then create the handler function itself which our lambda will invoke. stream = ( ) AWS = ( ) S3 = AWS.S3({ : }) sharp = ( ) BUCKET = process.env.BUCKET URL = readStreamFromS3 = { S3.getObject({ Bucket, Key }).createReadStream()
} writeStreamToS3 = { pass = stream.PassThrough() { : pass, : S3.upload({ : pass,
      Bucket, : ,
      Key
    }).promise()
  }
} streamToSharp = { sharp()
    .resize(width, height)
    .toFormat( )
} // resize.js // require modules const require 'stream' const require 'aws-sdk' const new signatureVersion 'v4' const require 'sharp' // create constants const const `http:// .s3-website. .amazonaws.com` ${process.env.BUCKET} ${process.env.REGION} // create the read stream abstraction for downloading data from S3 const ( ) => { Bucket, Key } return // create the write stream abstraction for uploading data to S3 const ( ) => { Bucket, Key } const new return writeStream uploadFinished Body ContentType 'image/png' // sharp resize stream const ( ) => { width, height } return 'png' Here we’re defining constants and the constructor functions for our streams. What’s important to note is that S3 doesn’t have a default method for writing to storage with a stream. So you need to create one. It’s doable with the helper. The abstraction above will write the data with a stream and resolve a promise once it's done. stream.PassThrough() Moving on, let’s check out the handler. Just underneath the code above, paste this in. exports.handler = (event) => { key = event.queryStringParameters.key match = key.match( ) width = (match[ ], ) height = (match[ ], ) originalKey = match[ ] newKey = + width + + height + + originalKey imageLocation = { readStream = readStreamFromS3({ : BUCKET, : originalKey }) resizeStream = streamToSharp({ width, height }) { 
      writeStream, 
      uploadFinished 
    } = writeStreamToS3({ : BUCKET, : newKey }) readStream
      .pipe(resizeStream)
      .pipe(writeStream) uploadedData = uploadFinished .log( , {
      ...uploadedData, : URL, : imageLocation
    }) { : , : { : imageLocation }, : }
  } (err) { .error(err) { : , : err.message
    }
  }
} async const // match a string like: '/1280x720/image.jpg' const /(\d+)x(\d+)\/(.*)/ // get the dimensions of the new image const parseInt 1 10 const parseInt 2 10 const 3 // create the new name of the image, note this has a '/' - S3 will create a directory const '' 'x' '/' const ` / ` ${URL} ${newKey} try // create the read and write streams from and to S3 and the Sharp resize stream const Bucket Key const const Bucket Key // trigger the stream // wait for the stream to finish const await // log data to Dashbird console 'Data: ' BucketEndpoint ImageURL // return a 301 redirect to the newly created resource in S3 return statusCode '301' headers 'location' body '' catch console return statusCode '500' body The query string parameters will look like this . Which means we grab the image dimensions from the parameters by using a regex match. The value is set to the dimensions followed by a and the original name of the image. This will create a new folder named with the image in it. Pretty cool. /1280x720/image.jpg newKey / 1280x720 image.jpg Once we trigger the streams and await the promise to resolve we can log out the data and return a 301 redirect to the location of the image in the bucket. Note that we will enable static website hosting on our bucket in the next paragraph. Write S3 Bucket configuration The bucket configuration will mostly consist of default templates, so if you’re a bit rusty, I’d advise you brush up a bit. But, the gist of it is simple enough to understand. Open up the folder and create a file. CloudFormation bucket serverless.yml service: image-resize-on-the-fly-bucket

custom:
  secrets: ${file(../secrets/secrets.json)} # will be created our deploy.sh script

provider:
  name: aws
  runtime: nodejs8 stage: ${ :STAGE, }
  profile: serverless-admin # or change to region: us-east environment:
    BUCKET: ${ :BUCKET}

resources:
  Resources:
    ImageResizeOnTheFly:
      Type: AWS::S3::Bucket # creating an S3 Bucket
      Properties:
        AccessControl: PublicReadWrite
        BucketName: ${ :BUCKET}
        WebsiteConfiguration: # enabling the website option
          ErrorDocument: error.html
          IndexDocument: index.html
          RoutingRules: # telling it to redirect every error
            - 
              RedirectRule:
                HostName: ${ :custom.secrets.DOMAIN} # API Gateway domain
                HttpRedirectCode: # temporary redirect HTTP code
                Protocol: ReplaceKeyPrefixWith: # route
              RoutingRuleCondition:
                HttpErrorCodeReturnedEquals: KeyPrefixEquals: ImageResizeOnTheFlyPolicy:
      Type: AWS::S3::BucketPolicy # add policy public read access
      Properties: 
        Bucket: 
          Ref: ImageResizeOnTheFly
        PolicyDocument: 
          Statement: 
            - 
              Action: 
                - Effect: Resource:
                Fn::Join: 
                  - - 
                    - - 
                      Ref: ImageResizeOnTheFly
                    - Principal: in .10 env 'dev' 'default' -1 env env static for 404 self "307" "https" "${self:provider.stage}/resize?key=" "404" "" for "s3:*" "Allow" "" "arn:aws:s3:::" "/*" "*" Once we enable the static website hosting option on our bucket, it will behave like any website. This lets us serve images from it and utilize the 404 error redirect rule. If no image is found, the bucket will trigger the 404, which redirects to our lambda function. Then resize the original image to the requested dimensions, and put it back to the bucket at the exact route it was requested from. Just like magic! Deploy with Docker Here comes the fun part! We’ll create a and file to create our Amazon Linux container and load it with values. That's easy. The hard part will be writing the bash script to run all commands and deploy our function and bucket. Dockerfile docker-compose.yml .env Starting with the , here's what you need to add. Dockerfile FROM amazonlinux

# Create deploy directory
WORKDIR /deploy

# Install system dependencies
RUN yum -y install make gcc*
RUN curl --silent --location https: RUN yum -y install nodejs

# Install serverless
RUN npm install -g serverless

# Copy source
COPY . .

# Install app dependencies
RUN cd /deploy/functions && npm i --production && cd /deploy

#  Run deploy script
CMD ./deploy.sh ; sleep m //rpm.nodesource.com/setup_8.x | bash - 5 Because Amazon Linux is rather basic, we need to install both gcc and Node.js at the get-go. Then it’s as simple as any Dockerfile you’ve seen. Install the Serverless Framework globally, copy over the source code, install the npm modules in the directory and run the script. functions deploy.sh The file is literally only used to load the values. docker-compose.yml .env version: services:
  image-resize-on-the-fly:
    build: .
    volumes:
      - ./secrets: secrets
    env_file:
      - ./secrets/secrets.env "3" /deploy/ That’s it. The Docker part is done. Let’s write some bash. Starting out simple, we’ll define the initial variables, configure our serverless installation and deploy our function. # deploy.sh

# variables
stage=${STAGE}
region=${REGION}
bucket=${BUCKET}
secrets= # Configure your Serverless installation to talk to your AWS account
sls config credentials \
  --provider aws \
  --key ${SLS_KEY} \
  --secret ${SLS_SECRET} \
  --profile serverless-admin

# cd into functions dir
cd /deploy/functions

# Deploy '/deploy/secrets/secrets.json' "------------------" ' ...' "------------------" function echo echo Deploying function echo sls deploy Once we have deployed it, we need to grab the domain name of our API Gateway endpoint and put it in a file which will be loaded into our file from the directory. To do this I just did some regex magic. Add this at the bottom of your . secrets.json serverless.yml bucket deploy.sh # find and replace the service endpoint [ -z ${stage+dev} ]; then echo ; echo ; fi

sls info -v | grep ServiceEndpoint > domain.txt
sed -i domain.txt
sed -i domain.txt
domain=$(cat domain.txt)
sed domain.txt > id.txt
id=$(cat id.txt)

echo echo echo echo echo echo rm domain.txt
rm id.txt

echo > $secrets if "Stage is unset." else "Stage is set to '$stage'." 's@ServiceEndpoint:\ https:\/\/@@g' "s@/$stage@@g" "s@.execute-api.$region.amazonaws.com@@g" "------------------" "Domain:" "  $domain" "------------------" "API ID:" "  $id" "{\"DOMAIN\":\"$domain\"}" Now you have a file in the directory. All that's left is to run the bucket deployment. Paste this final snippet at the bottom of the script. secrets.json secrets deploy.sh cd /deploy/bucket

# Deploy bucket config
echo echo sls deploy

echo echo echo echo echo "------------------" 'Deploying bucket...' "------------------" 'Bucket endpoint:' "  http://$bucket.s3-website.$region.amazonaws.com/" "------------------" "Service deployed. Press CTRL+C to exit." There we have it! The coding part is done. Would you believe me we only need to run one command now? Open up a terminal window in the root of your project and run: $ docker-compose up --build Let it do its magic, and you’ll see everything get created automagically! Please note that the terminal will show you the bucket endpoint which you’ll use to access the images. Test with Dashbird The final step is to check if it all works. Let’s upload an image to the bucket, so we have something to resize. Go ahead and find an image you like and want to resize, or just take . this one It’s rather huge and around 6 MB in size. Here’s the command you want to run to upload it. $ aws s3 cp --acl public-read IMAGE s3: //BUCKET So, if your bucket name is and your image name is , then it should look like this if you run the command from the directory where the image is located. images the-earth.jpg $ aws s3 cp --acl public-read the-earth.jpg s3: //images Keep in mind you need to have the installed on your machine, or upload the image through the AWS Console. AWS CLI Now, try out to request the image through the bucket. Type into your browser the S3 bucket URL. http: //BUCKET.s3-website.REGION.amazonaws.com/the-earth.jpg You’ll see the original image appear. But, now add dimensions to the URL. http: //BUCKET.s3-website.REGION.amazonaws.com/400x400/the-earth.jpg This will trigger the resize function and create a 400x400 pixel version of the image. It’ll take a few hundred milliseconds to create and once it’s done, the browser will redirect you to the newly created image. When you try to refresh the URL you’ll see that it’s now fetching the new image, without calling the resize function. Let’s check the logs in and make sure it all works fine under the hood. Dashbird Looks fine, but I did make some beginner mistakes when I first tried setting up the function. One of them was forgetting to require a module before using it. Luckily I immediately got an alert that explained what was wrong. are life-savers. Slack alerts The way I fixed the issue was with the feature. It let me check the invocation logs with a few seconds of latency so I could debug the issue. Pretty cool. live-tailing Wrapping up To conclude this little session, I’d like to point out using serverless as a helper to support your existing infrastructure is incredible. It’s language agnostic and easy to use. showdev use clusters of containers for our core features that interact heavily with our databases while offloading all the rest to lambda functions, queues, streams and other serverless services on AWS. We at Dashbird And, of course, once again, give it a star if you want more people to see it on GitHub. If you follow along with the instructions there, you’ll be able to have this image resize on-the-fly microservice up and running in no time at all. here’s the repo If you want to read some of my previous serverless musings head over to or my profile join my serverless newsletter! I had an absolute blast writing this open-source code snippet. Writing the article wasn’t that bad either! Hope you guys and girls enjoyed reading it as much as I enjoyed writing it. If you liked it, slap that tiny unicorn so more people here on dev.to will see this article. Until next time, be curious and have fun. Originally published at dev.to .

A crash course on Serverless with AWS — Image resize on-the-fly with Lambda and S3

Installing Rails 6 on Ubuntu can be tricky. In 5 easy steps, I’ll show you how to do it. I’m currently a web development student at . As part of the curriculum, we’re expected to solve some Rails exercises from . microverse microverse The Odin Project I wrote this article as a way to help my fellow students. This may also help anybody interested in learning Rails. microverse Currently, The Odin Project of Rails (5.2.3). Installing this older Rails version is easy. But as Rails 6 catches on, the older version is bound to fall out of use. uses an older version It took me quite a while to figure out how to do this on my own. This article is meant to save you a couple of hours. That way you can get to work on the fun stuff sooner! Anyway, here’s how I installed Rails 6: Step 1. Prerequisites I installed Rails 6 on running on , but this HOWTO will probably also work for later Ubuntu and Xubuntu versions. Xubuntu 18.04.4 LTS Virtual Box 6.1.2 You can follow the from The Odin Project to set up your preferred Ubuntu distro. You can also install Ubuntu on a real machine if you prefer. Virtual Machine installation guide Step 2. Install rbenv and Ruby The from The Odin Project currently uses Ruby 2.6.5. For Rails 6 we can install up to Ruby 2.7. , Ruby 2.7 has been known to cause warning messages when used with Rails 6. If you don’t really need the latest Ruby version, you can use instead. This might save you a few warning messages later on as you work with rails. Ruby installation guide However 2.6.3 Open your terminal, and run the following set of commands $ sudo apt-get update $ sudo apt-get install curl git nodejs gcc make libssl-dev libreadline-dev zlib1g-dev libsqlite3-dev g++ libpq-dev $ git https://github.com/rbenv/rbenv.git ~/.rbenv clone $ ‘ PATH=” /.rbenv/bin: ”’ >> ~/.bashrc echo export $HOME $PATH $ ‘ “$(rbenv init -)”’ >> ~/.bashrc echo eval $ exit These will install rbenv and close your terminal window. You will need to open a new terminal window for the PATH changes to take effect. To install Ruby 2.7.0, open a new terminal, and enter these commands: $ mkdir -p “$(rbenv root)”/plugins $ git https://github.com/rbenv/ruby-build.git “$(rbenv root)”/plugins/ruby-build clone $ rbenv install 2.7.0 --verbose $ rbenv global 2.7.0 This is probably the most time-consuming part of the HOWTO, so be patient. Once Ruby is done installing, you’ll be ready for the next step. Step 3. Install Rails This step is pretty straight-forward. Instead of installing the older version of Rails, as detailed , we’ll simply install Rails 6.0.2.2: in The Odin Project Guide $ gem install rails -v 6.0.2.2 Step 4. Required additional components When I first tried to install Rails 6 on my virtual machine, I thought the previous step would be all there was to it. But I was wrong! At this point, if you try to run something like rails new my_first_rails_app you’ll get a series of error messages. To fix this, you’ll have to install these recent versions of the following components: Step 4.a. Nodejs To install the nodejs version required by Ruby 6, run: $ curl -sL https://deb.nodesource.com/setup_12.x |sudo -E bash - $ sudo apt-get install -y nodejs $ curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add - Step 4.b. Bundler and pg Bundler will allow you to load the necessary dependencies from Gemfiles, which are used by Rails apps. Pg is a Ruby gem you’ll need to communicate with PostgreSQL. To install these, do: $ gem install bundler:2.1.4 $ gem install pg Step 4.c. Yarn You will need yarn to be able to run rails server and test your Rails 6 apps. To install the necessary version, run: $ “deb https://dl.yarnpkg.com/debian/ stable main” | sudo tee /etc/apt/sources.list.d/yarn.list echo $ sudo apt update && sudo apt install yarn $ yarn install --check-files Step 5. Test Rails Finally, you’ll want to make sure everything works as intended. To do this, I suggest you clone and run some tests on it. This repository contains we did from The Odin Project at microverse: my Toy App Github repository one of the first Rails exercises $ git https://github.com/voscarmv/toy_app clone $ toy_app cd $ bundle install $ rails db:migrate $ rails server This should serve the Toy App homepage to Play around with it and see how it works. http://localhost:3000/ NOTE: If you run into errors when running bundle install, try running yarn install --check-files again. That will likely fix the problem. If you decided to use Ruby 2.7 You might be getting warning messages when running or any other rails command. I suggest you point to the 6-0-stable branch of the rails 6.0.2.2 gem in your Gemfile. rails c Your Gemfile should look something like this: Conclusion and acknowledgments I hope this HOWTO helped you save some time. If you run into trouble while trying it out, leave a comment or . I’ll do my best to help you out! contact me on Twitter Finally, a special thank you to my coding partner for helping me find most of the commands from Step 4. I wouldn’t have been able to finish this guide so soon without his help! Alexis

Installing Ruby on Rails 6 on Ubuntu 
[A How-To Guide]

I am on Microverse working with a lot of people new to Software Development with Linux (I use this word to refer to and all his derivatives or distros), and in web development we use certain tools and pipelines that are more difficult to set up in Windows. So I found that most of the people new to Linux struggle to set up the tooling and basic commands for the first time. Linux OS This article tries to provide my dev environment as an example (I am not affiliated or related to any site or tool mentioned or linked here). I am using Debian 9, but most of the commands are similar in derivative distros as Ubuntu, Elementary, Mint or LinuxMX, e.g. all the ones that use ` ` or packages ` `.  I'll assume the one reading this article will just copy-paste the commands. apt .deb To me a great develop environment needs: An IDE or good text editor version control system the programming languages for you to develop some useful tools and utilities I will concentrate myself in web development, so I'll go installing the following stack: text editor, along some extensions for  web development vscode: version control standar, and some functions, aliases and tricks git: git JavaScript runtime nodejs: for web developers (screenshots, GIMP, VLC, Slack, teamViewer and dev fonts) some useful tools If you found some commands to be outdated or wrong for you, please comment the command that worked for you, along with your specs. I must note this is my actual machine, kernel and specs: Prerequisites Please be sure you have access running sudo sudo whoami Must return , if not visit this . From now on, when you type you must enter your password on the terminal. root link sudo Check if  system is updated: sudo apt update
sudo apt upgrade -y When you are ready, install these packages for develop in Linux: sudo apt install make curl build-essential openssl libssl-dev unzip A nice editor: Visual Studio Code The easiest way to install it is using the precompiled package from Microsoft (press the button that says ). You'll get in your folder (or the place the browser put the file) a package. But double click it won't do any help, you must install it using your terminal. Go ahead and open a terminal, then type (don't forget to changes the "x" in the command to the numbers in your file) : here .deb Debian, Ubuntu ~/Download .deb sudo apt install ./code_x.xx.x-xx_amd64.deb Also you can use tab for auto completion, learn . will auto magically set up everything and when all is finished you can open from your terminal (typing ), menu or launcher. here apt vcsode code Extensions for VSCode VSCode have a lot of extension on their , but filtering only web development extensions we found a great selection. The following are my favorites: Marketplace Auto Complete Tag Bracket Pair Colorizer 2 Color Manager Path Autocomplete Prettier <Your choices here> How to install them? One way is searching those on the marketplace and copy the command for install, for example: Then inside of VSCode press or in the menu go to then and you'll get: Ctl+P View Command Pallete Paste and and the extension would be installed. More info . Enter here A standard version control system: git Luckily for us, git is super easy to install: sudo apt install git
git --version You must be greeted with your git's version. But we have to make an extra setup: identify yourself. For this you need to create an account. Provide your name and email address, Git embeds this information into each commit we do, like this: git config --global user.name git config --global user.email "Your Name" "your.name@domain.com" Remember to put your name (or nickname) and your email. Now you should have Git installed and ready to use on your system. functions, aliases and tricks git As git is so important in modern development, its great to know that we have several utilities and helper for manage git. And most of them are available for Debian. One way is to use ` ` terminal commands, like ` `. Talking about  config you can use ` `to get info about certain repository, like the GitHub/GitLab repository or the branches you had worked on. git git config git config -l As you can notice on the last screenshot I use some aliases or helper functions. In the aliases dept I like to use short versions of normal commands. For example instead of ` i can use only ` ` or even ` `, is up to you. You can find a good guide about what aliases are people recommending and how to set up. git checkout` git check git ch here Did you commited something that was not supposed to commit (like secret keys!) or messed up working code? I found helping where you found a comprehensive guide for fixing bad commits/push/merges. this guide Do you want to learn the gory details? is your friend! This free official book Developing for JavaScript: install NodeJS I found difficult to install in Windows in comparison to install it on Linux, and this was one of the main reason I fully embraced Ubuntu and later Debian as my main OS. If you want to program for the web you will need sooner or later. node NodeJS To install the current LTS version (other versions ) you must use your terminal: here curl -sL https: sudo apt install -y nodejs //deb.nodesource.com/setup_12.x | sudo bash - From here you can use all the packages and helpers from node and npm. Here is for getting started. a quick guide Now you can use VSCode for making scripts and code to run over NodeJS, save it in a repository using Git and share it to the world. Go out there and find ! some great resources to learn Some useful tools for web developers in Debian : all Debian variants have support for using Print key, but if you want something more let me recommend you . Screenshots OBS For manipulate (raster) images you have The GIMP, but if you prefer something easy but powerful try . Pinta If you want to be in touch with your team you can install or , but of them using your terminal. Slack Teamviewer I recommend for your terminal or VSCode, another good choice is . Jetbrains Mono Fira Code Do you have more useful tools for web developers on Debian? Any comment or suggestion? Feel free to comment and share! Lets use Debian at full capacity!

Stories, News & Mentions about NOVOSOURCE

Novosource’s Stories on HackerNoon

Novosource's News & Mentions