teleren/devto huggingface dataset:
Semantic Versioning
Published: 2023-04-27 16:35:39

Examples of Semantic Versioning https://semver.org/


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


## What is it?
Semantic Versioning (often abbreviated as SemVer) is a widely-used convention for versioning software. The goal of SemVer is to provide a standardized way to communicate changes to a software project, making it easier for developers to understand how different versions of a software package relate to each other and what changes they can expect when upgrading to a new version.

The basic format of a SemVer version number is MAJOR.MINOR.PATCH, where each of the components has a specific meaning

## How it works?

- **MAJOR** version: Indicates a major release with significant changes that are not backward-compatible with previous versions. Examples of changes that could trigger a major version increment include breaking changes to the public API, changes to the database schema, or significant changes to the user interface.

- **MINOR** version: Indicates a minor release with new features or functionality that are backward-compatible with previous versions. Examples of changes that could trigger a minor version increment include adding new API endpoints, introducing new configuration options, or adding new UI components.

- **PATCH** version: Indicates a patch release with bug fixes or other minor changes that are backward-compatible with previous versions. Examples of changes that could trigger a patch version increment include fixing a security vulnerability, addressing a bug that caused crashes, or improving the performance of existing code.

In addition to these three components, SemVer allows for the use of pre-release and build metadata. Pre-release versions are identified by appending a hyphen followed by a series of alphanumeric identifiers to the version number. Build metadata is identified by appending a plus sign followed by a series of alphanumeric identifiers to the version number. These components are not used to determine version precedence; instead, they are used to provide additional information about the version.

## Advantages
One of the key benefits of using SemVer is that it provides a clear and unambiguous way to communicate changes to a software package. By following the conventions of SemVer, developers can easily understand the nature of changes between different versions of a package and can make informed decisions about whether to upgrade to a new version.

Another benefit of SemVer is that it encourages good development practices. In order to use SemVer effectively, developers must carefully consider the impact of each change they make to a software package and ensure that version numbers are updated in a consistent and meaningful way. This can help to reduce the likelihood of introducing bugs or breaking changes into a software package, making it more stable and reliable over time.

## Conclusion
Semantic Versioning is an important convention for versioning software that provides a standardized way to communicate changes between different versions of a software package.
Wasp Hackathon #2 - Let's "hack-a-ton"!
Tags: hackathon, saas, ai, fullstack
Published: 2023-04-27 16:34:24

{% embed https://www.youtube.com/watch?v=ts2mQHLBnc0 %}

So Launch Week #2 has officially come to an end, and as the tradition goes, the end of the launch week means the beginning of a [hackathon](http://hackathon.wasp-lang.dev)!

We've launched a ton of new features for you to build your Hackathon project with, including:

* [full-stack auth](https://wasp-lang.dev/blog/2023/04/12/auth-ui)
    
* support for sending emails
    
* custom API routes
    
* full-stack type safety
    
* [one-line deployment to Fly.io](https://wasp-lang.dev/blog/2023/04/11/wasp-launch-week-two#thursday-apr-13---deploy-your-app-to-flyio-with-a-single-cli-command)
    

You can read it all in this [blog post](https://wasp-lang.dev/blog/2023/04/11/wasp-launch-week-two) or watch a 1-minute video showing how it all works in practice 🎬!


[![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/t6dqhjnngtwmsf5n45dh.png)](https://www.youtube.com/shorts/YDqh7dSW8ZQ)

Even better, we've got a new starter templates feature that lets you create a new project with a pre-built template, so you can get started even faster! Like this sweet [SaaS template with GPT, Stripe, SendGrid, and Tailwind UI](https://github.com/wasp-lang/SaaS-Templaate-GPT) already integrated:


[![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1a0b2n3umqxyb4ye8lcc.png)](https://github.com/wasp-lang/SaaS-Templaate-GPT)

Just run `wasp new my-project -t saas` and you're good to go.

The prizes for the hackathon include **an awesome Wasp-themed mechanical keyboard, tons of Wasp swag, and more cool stuff** (e.g., virtual hugs from the team)!

The only rule is to use Wasp, and you can build whatever you want (but both you and I know it's going to be a GPT-powered app, so make sure to use [our template](https://github.com/wasp-lang/SaaS-Templaate-GPT)).

The applications are open, and the hackathon starts on April 28th and ends on May 7th. You can apply (solo or with a team) here:

[🏆 Join the Wasp Hackathon 2.0! 🏆](https://hackathon.wasp-lang.dev)

Good luck and Happy Hacking 🐝🚀!

---

*Want to stay in the loop? →* [*Join our newsletter!*](https://wasp-lang.dev/#signup)
CodePen Banner Trick 🤖
Tags: codepen, css
Published: 2023-04-26 15:33:13

---
canonical_url: https://jd2r.hashnode.dev/codepen-banner-trick
---
Recently I've been playing around with CodePen in anticipation of my canvas game-making series I'll be publishing there soon. It caught my attention that you were able to change your profile with custom CSS, and I instantly started thinking if I could use this to bypass their PRO-only limitation on banner images.

Turns out that you can. By simply altering the background-image property of the banner, it's easy to change it to any image you want - I used one of the free assets that they provide from Unsplash.

## Process
We'll start by creating a pen to hold our profile styles in. I added the following CSS to take away my profile image and the pop-up that says "customize your banner with PRO", as well as make my username bigger and add the image.
```css
#pen-as-header-question {
  display: none;
}
#profile-image {
  display: none;
}
#profile-username {
  font-size: 26px;
}
#profile-header {
  background-image: url("https://images.unsplash.com/photo-1522252234503-e356532cafd5?crop=entropy&cs=srgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2ODI1MjA0MTY&ixlib=rb-4.0.3&q=85");
}
```
Notice that by taking `#profile-header` and setting the background image to an image, we can change it. I haven't tested, but I'm assuming this would work with GIFs as well.

Then we'll head our profile and select **Settings**.

![settings codepen](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9qn3fvao01rqkhpr0mdx.png)

Scroll down until you notice a section labeled **Custom CSS**. Enter the link of your styling pen in the box and it'll auto-update.

![custom css codepen](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pgt2zvdj76y7n651iukm.png)

And we're done! Check your profile for updates.

I think the best part about this is that we're not breaking any rules! This is all functionality that has been provided and not anything hacky.

Check out my [profile](https://codepen.io/jd2r) to see how it looks.

If this helped you, drop a follow and a like and follow my CodePen. Later! 👋
Finished Project 2
Published: 2023-04-27 16:24:09

Vercel Link: https://project-2-ten-pi.vercel.app/
GitHub Repo: https://github.com/carter2625/project-2

We went with five elements to breakup our project to create different aspects of our frontend and backend design. files such as edu-badge and project-2 focused mainly on frontend with the design of the badges plus other aspects, while badge-list and search-bar incorporates both frontend and backend functionality making requests for the badges and filtering search results based on the badges retrieved. The most difficult part of this project was making sure the search function was communicating with the backend properly to filter results from our badges that were delivered. The part that was easier than expected was designing the frontend assets with the badges and the look of the site.
The Internet is Like a Convention: Why You Should Grab the Mic and Start Talking
Tags: webdev, programming, react
Published: 2023-04-27 16:24:03

The rise of the internet has given everyone a voice, a platform to speak their minds, and share their ideas. It's like a convention where anyone can grab the mic and become a speaker. But how many people actually take advantage of this opportunity?

According to the 1-9-90 rule, only 1% of people grab the mic and become active creators of content. Another 9% actively listen and engage with the content, while the remaining 90% are mere spectators who simply mill around and criticize those on stage.

However, it's on the stage where the real magic happens. The stage is where ideas are shared, collaborations are formed, and innovation is sparked. So, why not grab the mic and start talking?

As developers, we are fortunate to have an abundance of tools and resources at our disposal to create and share our work. Whether it's starting a blog, creating a video tutorial, or contributing to an open-source project, there's no shortage of ways to showcase our skills and make our voices heard.

By taking advantage of these opportunities, we not only improve our own skills and knowledge but also contribute to the larger tech community. Sharing our experiences and expertise can inspire others, spark new ideas, and ultimately drive innovation.

Of course, stepping up to the mic can be daunting. Fear of judgment, imposter syndrome, and lack of confidence can hold us back. But remember, no one starts out as an expert. Every great developer was once a beginner, and every successful content creator was once unsure of themselves.

So, don't be afraid to put yourself out there and make your voice heard. Whether it's through writing, speaking, or contributing to a project, your unique perspective and experiences are valuable and worth sharing.

The internet is like a convention, and the stage is where the good stuff happens. So, grab the mic and start talking. You never know who might be listening and where it might take you.

By embracing the opportunities and resources available to us as developers, we can make our mark on the industry and contribute to the larger tech community. Don't let fear hold you back from sharing your ideas and experiences. Step up to the mic and make your voice heard.
Segmenting my audience
Tags: community, webdev, buildinpublic, programming
Published: 2023-04-27 16:21:50

Hi everyone!

After a long time reading DevTo contents I've started posting about my projects but soon after that I've realized that my writings were not a good fit for the community, which looks more interested in tech other than products (but if I am wrong, happy the learn that!).

From now on I'll try sharing only tech related topic here, which is a perfect fit, because you know, we have soooo much to learn from each other!

That said, here is my latest post, hoping to find Lisp/Scheme/Guile enthusiasts around the corner :) https://fpsd.codes/random-bits.html
Ruby Lambda VS Proc
Tags: ruby, proc, lambda
Published: 2023-04-27 16:07:10

Lambda and Proc - both are container for a block of code. Define a set of codes inside either of them and save them as a variable for later use.

Let's see the usage of both in detail

## Lambda
A lambda is very similar to method, just the syntax varies. Below is the syntax for creation
```
test_lambda = -> { puts 'something'}

# lambda using arguments
test_lambda = -> (x) { x + 1}
```

Now we have defined a lambda and store in a variable `test_lambda`, we have to call it to use. There are multiple ways to call a lambda. Below is the list of ways
```
test_lambda.call
test_lambda.call()
test_lambda.()
test_lambda.[]
test_lambda.[]
test_lambda.===
```
I prefer `.call()` as it is more readable than others

If we call the defined lambda, the block of code is executed and result is displayed
```
test_lambda.call(5)
6
=> 6
```

As I stated earlier, lambda works very similar to methods if lambda is defined with args, the number of args should match during call, else it will raise an exception just like a regular method.

Also like a regular method a lambda will return normally to it's `__callee__` rather than returning from a context

Example
```
def demo_lambda(num)
  test_lambda = -> (x) { return x + 1 }
  new_value = test_lambda.call(num)
  puts 'new value returned'
  new_value
end
```
Here the return of the test_lambda will return the value within the scope of the lambda (i.e returned value is stored in `new_value`) and will proceed with the execution of below lines

## Proc
Procs are similar to lambda, but there are few differnces and the choice to use between Proc and Lambda depends on it

Proc creation uses different syntax
```
test_proc = Proc.new {|x| x+1 }
```

Calling Proc is similar to lambda. It can be called using `.call(), .(), .[], .===`

Proc doesn't care about the number of arguments passed. But if the argument is used for any kind of calculation or manipulation it will raise an error. 

Example
```
p = Proc.new{|x| puts 'something'}
p.call()
=> "Something"

p = Proc.new{|x| x*2 }
p.call()
(irb):61:in `block in <main>': undefined method `*' for nil:NilClass (NoMethodError)
                                                                                
p = Proc.new{|x| x*2 }

#since there is a calculation based on the args passed NilClass error is thrown
```

One more major difference is proc will return from the current context. i.e if proc is inside an method, then calling return from proc is equivalent to returning from that method. Let's see an example
```
def demo_proc(num)
  test_proc = Proc.new{ |x| return x + 1 }
  new_value = test_proc.call(num)
  puts 'new value returned'
  new_value
end

demo_proc(5)

irb(main):008:0> demo_proc(5)
=> 6
```

In the above sample, the puts statement will not be printed. This is because the return in test_proc will return from the demo_proc itself.

Source: [Proc](https://ruby-doc.org/core-2.6/Proc.html) [Lambda](https://ruby-doc.org/core-2.6.3/Proc.html#method-i-lambda-3F)
Streamlining Your Work with Custom Excel Functions
Tags: excel, productivity, programming, vba
Published: 2023-04-27 16:03:39

Excel is a powerful tool for organizing and analyzing data, but sometimes you may find yourself needing to perform a task that isn't covered by the built-in functions. Fortunately, you can create your own custom functions in Excel using VBA.

In this article, we'll walk through the process of creating a custom function that can take multiple cell inputs and format them into a string.

1. Open the **Visual Basic Editor** and create a new module.
2. Write the function code, using the **ParamArray** parameter to accept a variable number of arguments.
3. Save the module and return to the Excel workbook.
4. Test the function by entering it into a cell.

Here's the code for the custom function:

```vbnet
Function MySqlValues(ParamArray vals()) As String
    Dim str As String
    str = "("
    For i = LBound(vals) To UBound(vals)
        If VarType(vals(i)) = vbString Then
            str = str & "'" & vals(i) & "',"
        Else
            str = str & vals(i) & ","
        End If
    Next i
    str = Left(str, Len(str) - 1)
    str = str & ")"
    MySqlValues = str
End Function
```

This code defines a new function called **MySqlValues**. The **ParamArray** parameter allows the function to accept a variable number of arguments. The For loop iterates over each argument and checks its data type using the **VarType** function. If the argument is a string, it is enclosed in single quotes. The resulting string is returned as the function value.

To test the function, enter it into a cell along with the cell references for the inputs you want to use. For example, `=MySqlValues(A1,B1,E1)` would take the values from cells **A1**, **B1**, and **E1**, and format them into a string.

Custom Excel functions can help you work more efficiently and accomplish tasks that would otherwise be impossible. By learning to create your own functions, you can get more out of this powerful tool.
YAML: A Powerful Data Serialization Language
Tags: webdev, javascript, xml, docker
Published: 2023-04-27 16:00:40

As a developer, you need efficient ways to handle data serialization and configuration management. YAML (YAML Ain't Markup Language) is a human-readable data serialization language designed for simplicity and readability.

**Why YAM**L =>
YAML is a language for exchanging information between systems. It simplifies configuration file writing, data exchange between programming languages, and metadata representation.

**Usage of YAML** =>
Configuration Files: YAML's human-friendly syntax and indentation-based structure make it ideal for defining complex configurations in tools like Ansible, Docker Compose, and Kubernetes.

Data Exchange: YAML is a versatile format for cross-platform data exchange. It allows you to serialize and transmit data structures across different programming languages.

Metadata Representation: YAML can represent metadata for web pages, software projects, and more. It offers an elegant way to define titles, descriptions, and keywords.

**Advantages of YAML** =>
Readability: YAML's clean syntax and structure make it easy to read and modify. Its human-friendly format reduces debugging time.

**Simplicity**: YAML is concise and intuitive, focusing on essential elements. It represents complex data structures using key-value pairs and lists.

**Language Independence**: YAML is compatible with multiple programming languages, ensuring seamless integration between systems.

**Flexibility**: YAML supports various data types and allows comments, providing context within the data structure.

Examples of YAML =>

**Example 1: Docker Compose Configuration**
version: '3'
services:
web:
build: .
ports:
- "80:80"
db:
image: postgres
environment:
- POSTGRES_PASSWORD=secret

**Example 2: Data Serialization**
- name: John Doe
age: 35
department: IT
skills:
- Java
- Python
- name: Jane Smith
age: 28
department: HR
skills:
- Communication
- Recruitment

**Example 3: Metadata Representation**
title: My Awesome Website
description: A showcase of YAML's power
keywords:
- YAML
- Data serialization
- Configuration

**Conclusion **=>
YAML offers simplicity, readability, language independence, and flexibility. Its usage in configuration files, data exchange, and metadata representation demonstrates its versatility. Incorporating YAML into your projects can enhance productivity and enable seamless communication between systems.
DevOps Job Opportunity
Published: 2023-04-27 16:00:06

📌 Are you aware of what DevOps Mindset is?

DevOps is an approach aimed at improving the interaction and communication between software development and operations teams, with the goal of creating an agile and efficient work environment for delivering quality software. This philosophy is based on practices such as process automation, continuous integration and delivery, and emphasizes the importance of collaboration and feedback between teams.

In summary, DevOps seeks to break down barriers between development and operations, allowing teams to work together to deliver software faster and with higher quality, while promoting a culture of continuous learning and constant improvement.

Are you the person we are looking for at COCUS Portugal? 😎
. https://lnkd.in/dpMbc2xg
Unartificial Intelligence
Tags: intelligence, hbr
Published: 2023-04-27 15:58:56

Excerpt from the HBR article

- The human mind could see the moments clearly without remembering any details before or after.

- From David Eagleman's **Livewired**:

> The brain is like citizens of a country establishing friendships, marriages, neighborhoods, political parties, vendettas, and social networks. Think of the brain as a living community of trillions of intertwining organisms…a cryptic kind of computational material, a living three-dimensional textile that shifts, reacts, and adjusts itself to maximize its efficiency.

- The more we learn, the more we learn how much we don’t know.

Ref. https://hbr.org/2020/11/unartificial-intelligence
By [Scott Berinato](https://hbr.org/search?term=scott%20berinato)
Crear plantilla de Email con Laravel 10 y enviar un correo
Published: 2023-04-27 13:56:51

Laravel tiene un sistema genial para el envío de correos. En este artículo no vamos a contar como configurarlo, sino que vamos a ir directamente a como se envía un correo.

Para crear una plantilla de correo electrónico, que además será parametizable, primero tenemos que lanzar una orden que nos va a crear los ficheros necesarios:

```
php artisan make:mail UsuarioCreadoParaEnvioComunicaciones --markdown=emails.usuario_creado_para_envio_comunicaciones
```

Crea dos ficheros, una clase tipo Mailable:

> app/Mail/UsuarioCreadoParaEnvioComunicaciones.php

Y un fichero donde se pondrá el texto del email:

> resources/views/emails/usuario_creado_para_envio_comunicaciones.blade.php

Nos vamos al fichero `UsuarioCreadoParaEnvioComunicaciones.php`:

En el método `__construct`, vamos a poner las variables que queremos pasarles al correo electrónico:

```
public function __construct(public Inscripcion $inscripcion, public string $password) { }
```

Y que no se nos olvide poner en la cabecera:

```
use App\Models\Inscripcion;
```

Y cambiamos el asunto del email en el campo subject del método `envelope()`.


Ahora nos vamos al fichero `usuario_creado_para_envio_comunicaciones.blade.php` y lo modificamos al gusto:

```
@component('mail::message')
![{{ $inscripcion->elcongreso->nombre }}]({{ $inscripcion->elcongreso->logo }})

# {{ $inscripcion->elcongreso->nombre }}

Estimad{{ $inscripcion->o_a() }} {{ $inscripcion->nombre }},

@if($password == "La que usted tenía anteriormente")
**Aparece en nuestros sistemas como usuari{{ $inscripcion->o_a() }} registrad{{ $inscripcion->o_a() }} en el portal de congresos.**
@endif

A continuación le explicamos los pasos a seguir para realizar su primer acceso y proceder a registrar sus comunicaciones:

* [{{ route('mis-comunicaciones.index', $inscripcion->elcongreso->elcongreso) }}]({{ route('mis-comunicaciones.index', $inscripcion->elcongreso->elcongreso) }})

* Indique su dirección de correo electrónico y su clave:

 * **{!! $inscripcion->email !!}**

 * **{{ $password }}**

Reciba un cordial saludo.

{{ $inscripcion->elcongreso->nombre }}
@endcomponent
```

Para probarlo podemos lanzar este código:

```
Mail::to('pruebas@gmail.com')->send(new App\Mail\UsuarioCreadoParaEnvioComunicaciones(App\Models\Inscripcion::find(38), 'password'));

Mail::to('pruebas@gmail.com')->send(new App\Mail\UsuarioCreadoParaEnvioComunicaciones(App\Models\Inscripcion::find(38), 'La que usted tenía anteriormente'));
```

Un saludo!
how to access AWS Credentials from Parameter store in Terraform Provider.
Published: 2023-04-27 15:50:04

Hello,
I am trying to get the AWS Credentials already stored in my SSM Parameter Store and call them in my Terraform Provider so that i can Plan, Apply my terraform code.

i have tried the following code…

in variables i have:
variable “tf_access_key” {
default = “tf_access_key”
}
data “aws_ssm_parameter” “tf_access_key” {
name = var.tf_access_key
}

and then in Version.tf i have.
.
.
access_key = data.aws_ssm_parameter.tf_access_key.value
.
.
.

i am not sure if this is the correct way. i need suggestions how to get my correct credentials from the Parameter store and then us it in my provider. the access key and the secret key.
kindly help and suggest.

thanks in advance.

P.S. i need to do this because my ultimate goal is to run my code using CI CD Pipeline in aws.