teleren/devto huggingface dataset:
Amplication in TechCrunch's Top 50 Open-Source Startups in 2022
Tags: community, collaboration, news, opensource
Published: 2023-02-08 22:39:30

Since its launch, Amplication has experienced rapid growth. After securing seed financing in November 2021, the company introduced its Enterprise version in September 2022. The team has grown from zero to twenty of the world’s top professionals, all within one year. The Amplication team is committed to skyrocketing growth.

Verifying this fact, TechCrunch recently published an article about “[Which open source startups rocketed in 2022](https://techcrunch.com/2023/02/01/which-open-source-startups-rocketed-in-2022/?guccounter=1).”

Amplication was featured as one of the fastest-growing open-source startups in the world in 2022.

![Chart of top 50 startups of 2022](https://static-assets.amplication.com/blog/50-startups/50-startup-chart.png)

We would like to thank Amplication’s dedicated open-source community for their part in this success. Our achievements are mainly due to feedback, pull requests, feature requests, reviews, and other contributions from our community.

From the beginning, when planning each release, we have put the community’s needs first and taken their suggestions into consideration. To help the open-source community, we have started many campaigns, including Issues for First Timers and Meetups. Join our [Discord server](https://amplication.com/discord) to stay in touch.

The near future will see many new advances.  For example, we are currently in the v1 of Amplication, which includes many powerful features such as a plugin system, microservices architecture, continuous GitHub sync, and more.

We [recently launched our MongoDB plugin](https://amplication.com/blog/plugging-into-mongodb) for Amplication, which brings the number of DBs we support after MySQL and PostgreSQL to three. Moving forward, many new plugins will become available, providing more features and flexibility for users. We launched [Amplication Pro Plan](https://amplication.com/blog/amplications-pricing-model) in January 2023 for businesses that want to build to a larger scale, for advanced use cases that require more customizability, and when working with larger teams.  We also released the Enterprise Plan to meet the needs of large enterprises. Although we have launched our paid plans, we still provide Amplication services for free to our open-source community for small projects and individual users.

Building on these achievements, 2023 will be a year of transformation in which Amplication will continue to revolutionize the way backends are developed in the industry. Be a part of this journey and connect with us through our social media and community channels:

GitHub: [Give us a star](https://github.com/amplication/amplication)

Twitter: [Give us a follow](https://twitter.com/amplication)

Discord: [Join our open-source community](https://amplication.com/discord)
How To Manage Multiple Versions Of On-Prem Solutions
Tags: onpremsolution, multipleversions, automation, efficiency
Published: 2023-02-08 22:19:36

I have closely followed the organization's issues and challenges regarding on-prem solutions and managing multiple versions between customers. This has been a long-standing concern, and organizations are still looking for a reliable and effective solution to this problem. In this article, I will highlight the key issues and propose potential solutions to help organizations better manage on-prem solutions and multiple versions between customers.

One of the primary issues that organizations need help with on-prem solutions is the complexity of managing multiple versions. With different customers using different versions of the same solution, organizations need help to track which version is being used by whom and ensure that each customer is using the most recent and secure version. It can lead to security vulnerabilities, reduced efficiency, and increased costs.

Another issue organizations need help with on-prem solutions is the need for more visibility into the overall system. With so many different versions being used by different customers, organizations find it challenging to understand their system's overall health and identify potential issues before they become problems. It can lead to downtime, loss of data, and reduced customer satisfaction.

So, what can organizations do to overcome these challenges? The first step is to adopt a centralized version control system. This system should be designed to provide a single source of truth for all versions of the on-prem solution and to keep track of which versions are being used by which customers. It will help organizations ensure that each customer uses the most recent and secure version, providing greater visibility into the overall system.

Another potential solution is to adopt a more automated approach to managing on-prem solutions. It might involve using software tools to automate the deployment and management of multiple versions, reducing the need for manual intervention and reducing the risk of human error. It will help organizations to achieve greater efficiency, security, and customer satisfaction.

In conclusion, the challenges of managing on-prem solutions and multiple versions between customers are real and significant. However, with the right approach and tools, organizations can overcome these challenges and ensure that their systems are secure, efficient, and reliable. If you need help with on-prem solutions and managing multiple versions, consider adopting a centralised version control system and a more automated approach to managing on-prem solutions.
Uploading Source Maps for Angular
Tags: sentry, angular
Published: 2023-02-08 22:00:34

---
title: Uploading Source Maps for Angular
published: true
description: 
tags: #sentry #angular
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-02-08 21:15 +0000
---

Tired of sifting through confusing Sentry error messages? You're not alone.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gshf0l0a3k3wmz26quv9.jpg)

I recently struggled with uploading sourcemaps to Sentry, but after some head-banging and persistence, I've gained valuable experience that I want to share with you. 

**UPD. This post has been updated after a timely [follow up call](https://github.com/getsentry/sentry-javascript/issues/7234) with Sentry team.**

The task was to organise uploading sourcemaps process for our Angular application. However, these steps could also be useful for those working with React applications. 

To get started, I organized a testing environment by creating a simple app using the `ng new` command. I then connected my personal Sentry account and added the `Sentry.captureException("...")` function to the click event of a button. To easily deploy the app, I utilized the user-friendly service Netlify (which I highly recommend).

While I don't want to go into too much detail about setting the release version, I understand that some readers may be interested in exploring different approaches. If that's the case, I encourage you to take a look at this [discussion](https://github.com/angular/angular-cli/issues/5190).

Settings in angular.json should be like this:

```
"sourceMap": {
  "scripts": true,
  "hidden": true,
}
```

To simplify the process, I have compiled all the necessary commands into a bash script:

```
version_str=$(grep -Eo '\"version\"\:\s\"[0-9]\.[0-9]\.[0-9]+\"' package.json)
version=$(echo $version_str | grep -Eo '[0-9]\.[0-9]\.[0-9]+')
version="$version-production"
sentry-cli releases new "$version"
sentry-cli releases set-commits --auto "$version"
sentry-cli releases files "$version" upload-sourcemaps docs/
sentry-cli releases new "$version" --finalize
```

Also I have put all necessary auth credentials to .sentryclirc file like this:

```
[defaults]
org = <my-organisation-name>
project = <my-project-name>

[auth]
token=<my-token>
```

After doing all this you might still see *.map files in your build folder, but don't worry, they won't be visible in production.
I made a library that adds a metallic look to anything you throw at it
Tags: javascript, design, webdev, css
Published: 2023-02-08 21:50:40


![Shiny!](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q54kh6jfvbgfgsbut4wx.gif)

**TL;DR: Shiny metal UIs, baby. [Check it out over on Metalmorphism...](https://metalmorphism.com/)**

I've been obsessing over creating a high-end and unique metallic look that I feel has been sorely missing from the web. I've put quite a bit of effort into ensuring the implementation is lightweight, performant and cross-browser compatible.

Maybe Metalmorphism can bring a touch of metallic elegance to the web in 2023?

The library I've written lets you turn any HTML element into a metallic looking thing by giving it a certain classname. It generates the SVG code (filters and all) on the fly and renders the raster image to a canvas element that is placed inside the element. The library will respect the dimensions, as well as the background and border-radius properties of the element, using them all as parameters for the effect (even after the first render, if anything changes, dynamically).

I love metallic stuff. I think the aesthetic is timeless and compelling. Seeing something metallic in the world always gives me pause. I remember as a child being fascinated with metallic toys and such, even the cheap plastic stuff with a faux metal coat. When I got into web development, the skeuomorphic design trend was on the rise, and I remember it fondly. I feel like I am on a personal crusade to bring back some of the charm of this bygone era.
How to make a scroll progress indicator
Tags: webdev, tutorial, javascript, css
Published: 2023-02-08 21:48:48

One of the first things i wanted to learn in web dev after learning JS was making a scroll progress indicator. It's mostly used as a UI element that gives the user a better understanding of where they are in the website.
 
#HTML
With HTML we make a div (we'll call the scrollbar indicator) that contains our scrollbar. 
```html
    <div class="scrollbar-indicator">
        <div class="scrollbar">
        </div>
    </div>
```
<hr>
#CSS
Now with CSS we give the indicator a width of 100% and a thin height (like 2%). We also need to give it a position of fixed so the user can always see it on the top of the page. For the scrollbar itself we'll give it a height of 100% but a width of 0%, this will be important for our Javascript later. After that give it any background color you like!

```css
.scrollbar-indicator {
    width: 100%;
    height: 2%;
    position: fixed;

}

.scrollbar {
    height: 100%;
    background-color: black;
    width: 0%;
}
```
<hr>
#JS
Now for the Javascript, first we make two variables that contain the scrollbar and scrollbar indicator. Then we make a function that'll be used to later tell our scrollbar what percent of the website we're at. 

In that function we divide the windows `scrollY` property with the windows innerHeight subtracted from the the body's scroll Height. The `scrollY` property tells us how many pixels we passed from the top left of the window, while the scrollHeight property tells us the height of an element's content (meaning the border and padding is excluded). After this, we multiply it by 100. 

Now we make another function where we set the scrollbars width to the scrollbars value and use `requestFrameUpdate` to make sure the function reruns all the time so we can always get the new scroll percentage. So then there you hae it! That's how you make a scrollbar indicator. You can see a preview of the code i used as an example of the scrollbar indicator in the codepen below.

```js
var scrollContainer = document.querySelector('.scrollbar-indicator');
var scrollbar = scrollContainer.querySelector('.scrollbar');

function scrollPercent() {
    return ((window.scrollY) / (document.body.scrollHeight - window.innerHeight) * 100 );
}

function updateProgressBar() {
scrollbar.style.width = scrollPercent() + '%';
requestAnimationFrame(updateProgressBar);
}

updateProgressBar();
```
{% codepen https://codepen.io/lensco825/pen/JjBqaro %}


You can also make a horizontal scroll indicator by making the scrollbar vertical and have it's height equal the scroll percentage. If you have any questions you can ask in the comments below, otherwise thanks for reading and have a great day/night!
Iron Bank: Secure Registries, Secure Containers
Tags: security, containers, devops, tutorial
Published: 2023-02-08 21:45:00

**Iron Bank – DoD Centralized Artifacts Repository (DCAR)**

Long story short...**Iron Bank** Centralized Artifacts Repository is a trusted repository management system to store U.S. Department of Defense artifacts. All artifacts stored in Iron Bank are hardened according to the Container Hardening Guide. DoD containers are OCI compliant and also have DoD-wide reciprocity across classifications.

Some of the main points that reduce the container's attack surface:

* Image building must start with a trusted image with known content from a trusted source.
![container_Hardening_Guide](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9o5n6b4uv2aqj6rt1oyz.png)
* Use **distroless** images (which contain only application and its runtime dependencies, and don't include package managers/shells or any other programs you would expect to find in a standard Linux distribution). All **distroless** images are signed by [cosign](https://github.com/sigstore/cosign).
* The container image must be built with a non-privileged user in the build file.

Without further ado, let's give it a try. Platform one provides two front-ends when it comes to user experience:

1) Iron Bank DCAR

![IronBank repo](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kacmzkbg463zcv1kvom1.png)


2) [Harbor](https://goharbor.io/) instance registry


![Harbor](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/e9i7lxn4k49s8f65l90a.png)


One of the most used base images is Alpine Linux (a security-oriented, lightweight Linux distribution),which is a "security-oriented, lightweight Linux distribution based on musl libc and busybox". Next I'll search for the [official image](https://docs.docker.com/docker-hub/official_images/):
`docker search --format "{{.Name}}: {{.StarCount}}: {{.IsOfficial}}" alpine`

![docker alpine](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7lmmwfc9xkg8nnfjyzu6.png)

The Docker Official Images are a curated set of Docker repositories hosted on Docker Hub. I'm going to use [Snyk](https://snyk.io/) to scan the `alpine` image.

![Snyk scan](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mp964sr0fnxlpthp70am.png)

The scan found 18 issues most of which are Low severity vulnerabilities.

![Vulnerabilites](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6eljprgoc6zl2jwtvnq0.png)

Now I'll scan ironbank's `alpine` image, and the result of the scan showed that accordingly to Snky's [vulnerability database](https://security.snyk.io/): 

> you are currently using the most secure version of the selected base image

![IronBank alpine image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nb84xocrcat66z2gc5xw.png)

In conclusion I highly recommend Iron Bank container registry since is one of the central registries used by the U.S. Department of Defense, and is maintained by the [Platform One team](https://p1.dso.mil/). 


![USA](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4rh13orjj75wen0lwjw1.png)
AWS Cloud Quest: Integrating Serverless Applications Study Note
Tags: aws, cloud
Published: 2023-02-08 21:27:04

This is the DIY challenge of the Integrating Serverless Applications in AWS Cloud Quest.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ri8pl1vm4qnuqz4w5uwn.png)

`producer` Lambda
```
import boto3
import json
import time

# Boto3 - DynamoDB Client - Mode Info: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html
sqs = boto3.resource('sqs')

# Replace Queue name with Queue URL from Account
queue = sqs.Queue('Your-Queue-Name')

# AWS Lambda Function that publishes a message at Queue
def lambda_handler(event, context):

    message = {
        "coder_id": "123",
        "spot_id": "321",
        "timestamp": round(time.time() * 1000)
    }
    response = queue.send_message(MessageBody=json.dumps(message))

    return response

```

`consumer` Lambda
```
import json
import boto3

# Boto3 - DynamoDB Client - Mode Info: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html
sqs = boto3.resource('sqs')
dynamodb = boto3.resource('dynamodb')

# AWS Lambda Function that consumes event from Queue and writes at DynamoDB
def lambda_handler(event, context):
    if 'Records' in event:
        for record in event['Records']:
            payload = json.loads(record["body"])
            if 'coder_id' not in payload:
                raise ValueError('erro format')
            else:
                table = dynamodb.Table('checkinData')
                table.put_item(
                   Item={
                        'coderId': payload['coder_id'],
                        'timestamp': payload['timestamp'],
                        'spotID': payload['spot_id']
                        }
                )

    return {
        'statusCode': 200,
        'body': json.dumps(payload)
    }
```

### DIY Steps:
1. Create a new SQS Queue `diy`
2. Add Dead-letter queue to `MyMessageQueue`

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ras15wafbaex1z9y1mu9.png)
React Native ?
Published: 2023-02-08 18:09:22

Native React: Building Mobile Applications with React Native

React Native is a popular open-source framework for building cross-platform mobile applications using JavaScript and React. With React Native, you can build mobile apps for both Android and iOS platforms using a single codebase, which helps to reduce development time and costs.

What is React Native?

React Native is a framework developed by Facebook for building mobile applications that run natively on both Android and iOS platforms. It allows developers to build mobile apps using the same React library that is used for building web applications, which means that developers can reuse their existing skills and knowledge. The framework uses native components, which means that the apps built with React Native look and feel like native apps, rather than web apps.

Benefits of React Native

Cross-platform development: React Native enables developers to build apps for multiple platforms using a single codebase, which helps to reduce development time and costs.

Fast development: React Native uses a hot reloading feature that allows developers to see the changes they make in real-time, which speeds up the development process.

Access to native APIs: React Native provides developers with access to native APIs, which means that they can use native features such as camera, geolocation, and others.

Performance: React Native apps run natively on both Android and iOS platforms, which means that they have the same performance as native apps.

Community support: React Native has a large and active community of developers, which means that there is a wealth of resources and support available to help you build your app.

Building a React Native App

To build a React Native app, you need to have a basic understanding of React, JavaScript, and mobile app development. You also need to have the React Native CLI installed on your computer, as well as an IDE or code editor, such as Visual Studio Code.

Once you have the necessary tools and knowledge, you can start building your app by following these steps:

Create a new React Native project using the React Native CLI.

Design the UI for your app using React Native components.

Implement the logic for your app using JavaScript.

Test your app on both Android and iOS platforms.

Deploy your app to the app stores for others to download and use.

Conclusion

React Native is a powerful and popular framework for building cross-platform mobile applications. With its fast development and access to native APIs, it provides developers with a convenient and efficient way to build high-quality mobile apps. If you are interested in building mobile apps, React Native is definitely worth considering.
Suporte gratuito de até 10 anos e mais segurança com Ubuntu Pro
Tags: linux
Published: 2023-02-08 21:10:45

A [Canonical](https://canonical.com/), empresa desenvolvedora e mantenedora da distro [Ubuntu](https://ubuntu.com/), passou desde 2022 a oferecer um serviço de suporte sob assinatura, o [Ubuntu Pro](https://ubuntu.com/pro).

As **distribuições LTS (Long Time Suport)**, lançadas a cada dois anos, sempre no mês de abril dos anos pares, regularmente têm prazo de cinco anos de cobertura de suporte para atualizações críticas de segurança, com essa nova modalidade o prazo de suporte passa a ser de dez anos.

Essa expansão amplia em até dez vezes o número de pacotes disponíveis nos repositórios oficiais; também otimiza as correções de vulnerabilidades.

A cobertura por mais tempo traz um alívio na pressão das equipes de TI do setor corporativo pela modernização do hardware ou mesmo de aplicações do sistema ou softwares de terceiros executados no ambiente Ubuntu.

Usuários domésticos podem se inscrever no programa e obter a cobertura do Ubuntu Pro para até cinco máquinas de uso pessoal, para isso basta seguir os passos abaixo:

1. Abra o **Atualizador de Programas** e aguarde ele verificar as atualizações do sistema;

2. Clique no botão **Configurações**;

3. Acesse a aba **Livepatch**;

4. Clique sobre o botão **Anexar esta máquina**, para que seu dispositivo seja elegível para a assinatura gratuita;

5. Escolha **Iniciar essa sessão**;

6. Role até o fim da página e pare na em **Free for personal use**;

7. Faça o login no serviço do ** Ubuntu One**;

8. Marque a caixa de autorização do serviço;

9. Copie o token gerado;

10. Cole o token na tela do **Ubuntu Advantage**;

11. Fazer o login.

Caso encontre alguma dificuldade há informações na página que vão lhe ajudar, as versões LTS 20.04, 18.04 e 16.04 podem requerer alguns passos extras, mas podem ganhar o suporte estendido sem nenhuma restrição gratuitamente.

Você já usou ou está usando o Ubuntu? Qual versão LTS você tem mais familiaridade? Está pensando em usar uma versão antiga por mais tempo? compartilhe sua experiência nos comentários.