teleren/devto huggingface dataset:
Content & Tooling Team Status Update
Tags: puppet, community
Published: 2023-06-30 16:52:40

---
title: Content & Tooling Team Status Update
published: true
date: 2023-06-30 00:00:00 UTC
tags: puppet, community
canonical_url: https://puppetlabs.github.io/content-and-tooling-team/blog/updates/2023-06-30-status-update/
---

## Hello Again!!

Another relatively quiet week so we’ve not got a lot to say, but hope you are all enjoying the sun :).

## Workflow changes

Just a heads up, but as part of our security tightening efforts, in a few weeks all community pull requests will need to have their workflow runs approved by a maintainer. This means either a Puppet employee or a Trusted Contributor will be need to give your changes a quick ok before the workflows can run and the tests can begin. If your pull requests are not being given the ok please ping us on them or reach out to us directly through the community slack or any of the other verified lines of communication.

## Stdlib

You may have noticed some issues when upgrading to stdlib 9.0.0 due to the namespacing of functions, however we are pleased to announce that fixes for this have come in from [alexjfisher](https://github.com/alexjfisher) which resolved these issue, leaving you free to upgrade your dependencies.

## Community Contributions

We’d like to thank the following people in the Puppet Community for their contributions over this past week:

- [`puppetlabs-postgresql#1449`](https://github.com/puppetlabs/puppetlabs-postgresql/pull/1449): “puppetlabs/stdlib: Require 9.x”, thanks to [bastelfreak](https://github.com/bastelfreak)
- [`puppetlabs-postgresql#1448`](https://github.com/puppetlabs/puppetlabs-postgresql/pull/1448): “puppet/systemd: Allow 5.x & puppetlabs/concat: Allow 9.x”, thanks to [bastelfreak](https://github.com/bastelfreak)
- [`puppetlabs-stdlib#1378`](https://github.com/puppetlabs/puppetlabs-stdlib/pull/1378): “Add `use_strict_setting` parameter to `deprecation` function”, thanks to [alexjfisher](https://github.com/alexjfisher)
- [`puppetlabs-stdlib#1377`](https://github.com/puppetlabs/puppetlabs-stdlib/pull/1377): “Ignore Puppet’s `strict` setting when calling function without namespace”, thanks to [alexjfisher](https://github.com/alexjfisher) and the following people who helped get it over the line ([bastelfreak](https://github.com/bastelfreak))
- [`puppetlabs-vcsrepo#612`](https://github.com/puppetlabs/puppetlabs-vcsrepo/pull/612): “Allow specifying tmpdir for git wrapper script”, thanks to [nabertrand](https://github.com/nabertrand)

## New Module / Gem Releases

The following modules were released this week:

- [`puppetlabs-stdlib`](https://github.com/puppetlabs/puppetlabs-stdlib) (`9.2.0`)
- [`puppetlabs-sqlserver`](https://github.com/puppetlabs/puppetlabs-sqlserver) (`4.1.0`)
- [`puppetlabs-apache`](https://github.com/puppetlabs/puppetlabs-apache) (`10.1.1`)
Hi, everyone Let create a basic calculator in C# using Methods Below are some photos. You can check it out!
Tags: csharp
Published: 2023-06-29 23:41:23

`
using System;

namespace BasicCalculator
{
    class Program
    {
       static void Main()
        {
            MathsOperator();
        }

       static void MathsOperator()
        {
            string InpOne, InpTwo, ops;
            InpOne = "Please enter your first number";
            InpTwo = "Please enter your second number";
            ops = "Please enter your operator";

            Console.WriteLine("Welcome to my basic Calculator in C#");

            Console.WriteLine(InpOne);
            double num1 = Convert.ToDouble(Console.ReadLine());
            
            Console.WriteLine(InpTwo);
            double num2 = Convert.ToDouble(Console.ReadLine());

            Console.WriteLine(ops);
            string op = Console.ReadLine();

            if (op == "+")
            {
                Console.WriteLine(num1 + num2);
            }
           else if (op == "-")
            {
                Console.WriteLine(num1 - num2);
            }
           else if (op == "*") 
            {
                Console.WriteLine(num1 * num2);
            }
           else if(op == "/")
            {
                Console.WriteLine(num1 / num2);
            }
            else if (op == "%")
            {
                Console.WriteLine(num1 % num2);
            }
            else
            {
                Console.WriteLine("Invalid operator is found please enter the right operator");
            }
        }

    }
}``

`
How do you know if Data Science is a good fit for you?
Published: 2023-06-29 23:35:12

Are you thinking of a career change and wondering if Data Science is a right for you? 
Data scientist is a fantastic career with a tonne of potential for future growth.
    Start with asking yourself, are you a curious person? Analytic is about being a detective, data detective. You have to find the answer which might be hidden and not always easy to find. You have to be ready to work hard and look deep to find the right answer. You have to be ready. Sometimes you are not sure where to find the right answer, there will be a lot of mistakes. Finding the answer takes a lot of tries and errors. You have to be confident in your ability to solve the question even if it takes a certain amount of errors and fails before? Then you are a good fit for this career.
    Ask yourself: Do you have a good logical approach to work? Good Data Scientists have an analytical mindset. Data science is about logical thinking, generating more ideas and creativity in solving the problems. 
    Are you passionate about problem-solving?
Data science is all about problem-solving. Good Data Scientist is a curious person who likes to solve problems, likes puzzles, and is inspired when learning something new.
    Are you interested in strategy?
You have to find the data and help the business find its strategy. It will be one of the primary responsibilities.  
    Don't forget about statistics.
You don't need a big math background. You have to be comfortable working with numbers and statistics. It's a very important part of this job.
    Are you comfortable presenting your work to the audience and collaborating with them?
You have to present your work to a stakeholder with a non technical presentation so everybody can understand. You have to explain your strategy and help the business take action. If you are a comfortable presenter and ready to argue your case, then you are a good fit for you.
After answering these questions you still think this is for you and exactly what you want to get involved in? - great. Data is not going anywhere neither Data Analytics/Scientists, so, this is an excellent job market to be a part of. You will feel great to be a part of the decision making team. Data Analytics/Scientists play a crucial role in making a strategy for the business.
The beauty of being a Data Science is that you have a variety of industries to be in from health care to real estate, from fashion to marketing, technology ets. Data in everywhere if you like to have a variety. Data Science is your best option. I hope my post was interesting, informative, and inspiring.
How to create and plot graphs in Python
Tags: datastructures, graphs
Published: 2023-06-29 23:17:44

## Step 1: Install the python-igraph package

To get started, you'll need to install the python-igraph package. You can do this by running the following command in your terminal:

```
pip install python-igraph
```

## Step 2: Import the necessary modules
Once you have installed the package, you need to import the required modules in your Python script. You will typically need the igraph module and the plot module for visualization. Include the following lines at the beginning of your script:

```

import igraph as ig
from igraph import plot
```

## Step 3: Create a graph object
To create a graph, you can start by initializing an empty Graph object. You can then add vertices and edges to this object to define the structure of your graph. Here's an example that creates a simple graph with three vertices and two edges:

```
# Create an empty graph
g = ig.Graph()

# Add vertices
g.add_vertices(3)

# Add edges
g.add_edges([(0, 1), (1, 2)])

# Print the graph
print(g)
```

## Step 4: Visualize the graph

Now that you have created the graph, you can visualize it using the plot module. The plot function takes the graph object as input and generates a visualization of the graph. You can save the plot to a file or display it directly. Here's an example that saves the plot as a PNG image:

```
plot(g, "graph.png")
```

## Step 5: Customize the graph appearance
You can further customize the appearance of the graph by modifying various attributes. For example, you can change the color, shape, and size of the vertices, as well as the color and width of the edges. Here's an example that demonstrates some customization options:

```
# Customize vertex attributes
g.vs["color"] = "blue"
g.vs["size"] = 20
g.vs["shape"] = "square"

# Customize edge attributes
g.es["color"] = "red"
g.es["width"] = 2

# Create the plot
plot(g, "graph.png")
```

These are just a few examples of what you can do with python-igraph. The package offers many more functionalities for working with graphs, including various graph algorithms and community detection methods.
Day 773 : Wish
Tags: hiphop, code, coding, lifelongdev
Published: 2023-06-29 22:48:37

_liner notes_:
- Professional : Had our team meeting. It was good seeing everyone. Spent the rest of the day updating API reference and writing a blog post. Pretty quiet day.

- Personal : Went through tracks for the radio show and did some refactoring on my side project to be able to upload images to GitHub. I found an example where it is making requests to a blob endpoint, but then you have to get the blob and create a commit and then push to the commit. Still trying to wrap my brain around it. I got uploading to the blob endpoint working, I think. I get a response with a URL, but I can't visit it because I think it's because it's not an authorized request. Going to take it step by step.

![Overhead view of the coast of Painted Cove Trail, OR, USA with sparse vegetation with some dark green water](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kh1lq1hw2va7eayt4bx3.jpg)

Going to purchase some tracks from some artists on Bandcamp and put together my tweets to send on Friday. Going to go through the GitHub documentation and the example I found and try to piece everything together to get uploading an image generated from an HTML canvas to GitHub. I still didn't watch the new episode of "Secret Invasion". Maybe tonight. Wish me luck! haha

Have a great night!

peace piece
Dwane / conshus
https://dwane.io / https://HIPHOPandCODE.com
{% youtube tK7NygFA17M %}
Unlocking Git's Power: A student's first encounter
Published: 2023-06-29 22:30:14


What is Git? To most developers Git is a daily tool used in the workplace, but to budding students and self-taught beginners it is a step into a whole new world. A world that one should become familiar with else they may find themselves in a difficult position when the time comes to start typing in that terminal. However, I am not typing this today to chastise anyone but to give those who are unfamiliar a follow noobie's learning experience and takeaway and maybe also those devs who are much further along their path as a coder and wish to seek insight on a fresh mind.


## - The Power of Version Control
Version Control is the act of keeping up with your software code throughout it's changes. They are tools that devs normally use to maintain any changes to the source code. Here is an example of the basic workflow of version control using Git. 

Say we have a file named script.js that has a list of games I like. Upon changing said file and wanting to keep it updated I could do the following in the terminal:

```
git add script.js 
// Stages our file for commit
git commit -m "our comment here" 
// This commits our file and leaves a comment with it
```

If we did not have access to software tools such as these, I'm sure working would be a lot more difficult and troublesome especially in the workplace, where leads to my next point..

## - The Incredible Accessibility of Git
Using Git these past two weeks has opened my eyes to how interacting in a workplace can potentially be. Git has the ability for us to all work off the same repository with very little difficulty using push and pull commands. This is an amazing feature that allows not only a group in the workplace to work on a single project but also allows someone to work in different places need be. A group also has the ability to all work on separate parts of a project and then merge it all back together. For example say you started a project but your partner has already been working on it, here's how we would update our end of the repository:

```
// First let's get our project
git clone [project.url]
// Now since we have a partner who's ahead, let's create a remote that looks at their version
git remote add partner [partner's forked project url]
// now to get ours up to date, we pull from that remote
git pull partner main
```
At this point our project.js should be updated to the point of our partner's saved version.

In conclusion, I think Git is an amazing tool that the sooner you become accustomed to it the better. It brings tons to the table and you'll probably find yourself using it if you work with sites like Github(shocking I know). I hope you found this read enjoyable and Git what the fuss is all about.
Behind the Helm (June 2023)
Tags: news, kubernetes, crossword, community
Published: 2023-06-29 22:00:00

_This is the web edition of the Behind the Helm, Scaleway's monthly Kubernetes newsletter. For the best Kubernetes news in your inbox every month, [subscribe today](https://www.scaleway.com/en/kubernetes-newsletter/)!_

## Hello lovely subscribers!

It’s June, and with the new month comes a new edition of Behind The Helm. We’ve got our usual round-up of blog posts, podcasts and events news to keep you up to date with the cloud native world.

## Blogs & news

First up, we’ve got some tooling news: Red Hat has [brought Podman to the desktop](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!2-5fe-!3qql) with version 1.0 of their Community Edition! This release can help businesses streamline OpenShift workflows, and swiftly onboard developers who are new to cloud native.

Next is a fascinating read by the folks at OpenTelemetry, focusing on runtime observability in K8s. [Check it out](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!8-5fe-!3qql), and bring your debugging to the next level with your newly acquired tracing superpowers.

The awesome folks over at Inheaden connected 250,000 IoT devices to the cloud using K8s; [read the deep dive on our blog](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!8-5fe-!3qql)!

## Podcast episodes

The Changelog podcast covered the hallway track at the Linux Foundation’s Open Source Summit last month, and this month they’ve released their [last episode](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!z-5fe-!3qql) of that coverage — including some very cool guests.

If you want to keep up to date with all the WASM hype, check out [this episode](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!4-5fe-!3qql) of the Kubernetes Podcast with Justin Cormack, the CTO of Docker.

## Events

With summer coming, our Lille office is in full bloom. We’ll take advantage of its gorgeous terrace to host an edition of KubeTalks, our K8s-focused meetup. This event will be in French, and we’ll welcome Stephane Dessein, CTO of [Le Fourgon](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!c-5fe-!3qql), along with Bruno Flament, DevSecOps Kubernetes at [Whispeak](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!1-5fe-!3qql), who’ll discuss Kubernetes service traceability. [Save your spot](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek!x-5fe-!3qql)!

[Registration is now open](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek2m-5fe-!3qql) for KubeCon + CloudNativeCon in Chicago this November! Book your tickets, book your hotel—get hype.

Finally, our [DevRel team](https://twitter.com/Scaleway_devs) will also be attending [DevOpsDays Amsterdam](https://t.elements.scaleway.com/c/?t=b15feda-4mc-ek2l-5fe-!3qql) if any of you are there, we’d love to hang out! Come grab us for a chat and a coffee.

That’s all for now (apart from the crossword, of course) — see you all in July!

Yours,
[Eli](https://twitter.com/eliholderness) & the Scaleway [team](https://twitter.com/Scaleway_devs)


![A crossword puzzle](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pawdmgntgqscd8yrovf2.png)
GitHub’s Best Practices(Streamlining Collaboration and Maximizing Efficiency)
Tags: github, webdev, versioncontrol, git
Published: 2023-06-29 21:46:31



GitHub is an indispensable tool for developers and teams worldwide, offering a seamless platform for version control, collaboration, and project management. However, to fully leverage its potential, it is crucial to follow best practices that promote efficient workflows, maintain code quality, and facilitate smooth collaboration.
This article aims to explore some of the top GitHub best practices. It will help developers and teams optimize their productivity and achieve better results. 
This article also presumes that the readers are familiar with GitHub. The following are the best practices:

Repository organisation: A well-organized repository structure enhances clarity and accessibility. Follow these guidelines:
            a.Use descriptive and concise names for repositories.
            b.Create meaningful directory structures and avoid clutter.
            c.Leverage branches to isolate features, bug fixes, and experiments.
            d.Establish clear naming conventions for branches to facilitate understanding and                           collaboration .

Branching Strategy:Effective branching is crucial for managing parallel workstreams and enabling seamless collaboration.The following are the best practices for effective branching:
            a.Utilize the main branch as the stable production-ready codebase.
            b.Regularly merge branches into the main branch to prevent divergence and merge conflicts.
            c.Delete obsolete branches to maintain a clean and manageable repository.

Committing and Pull Requests:Practicing good commit and pull request habits ensures a clear and traceable project history. Here are some recommendations:
            a.Use commit messages in the present form. 
            b.Use descriptive and concise commit messages to provide clarity. 
            c.Make commits focused on a single logical change. 

Code Reviews:Code reviews are a vital part of maintaining code quality and knowledge sharing. Consider these best practices:
            a.Regularly view codes to catch bugs, improve code quality, and share knowledge.
            b.Utilize code review tools and integrations to automate and streamline the process.

Issue Tracking and Project Management:Leveraging GitHub's built-in issue tracking features enhances project management and team coordination. Consider the following:
            a.Create clear and concise issue templates to encourage comprehensive bug reports and feature requests.
            b.Assign issues to team members and establish priorities to streamline work allocation.
            c.Utilize labels and milestones to categorize and track issues effectively.
            d.Regularly update and close issues to maintain an accurate project status.
Testing in Elixir: Ensuring code quality
Tags: testing, beginners, programming, elixir
Published: 2023-06-29 21:29:05

Testing plays a crucial role in software development, helping to ensure code quality and identify issues before they manifest in production. When it comes to functional programming, one of the most popular languages is Elixir. We will explore testing in Elixir and discover how it can help to maintain the integrity of the code.

**Why test ?**

Before diving into the details of testing in Elixir, it’s important to understand why test is so important.

Elixir is a language that is built on solid principles of functional programming and offers powerful features for writing clean and concise code. However, even with Elixir’s elegance, errors can occur. By writing tests, you can verify the correctness of your code and avoid future issues.

Elixir provides a testing library called ExUnit, which provides a solid framework for writing tests. ExUnit makes it easy to create test cases and execute test suites. Let’s take a look at some basic concepts.

- Test Organization:
Tests in Elixir are organized into separate modules, usually within a directory called test. Each test module contains a series of test functions that check the expected behavior of the code.

- Writing Test Cases:
Test cases in Elixir are defined as functions that start with the test prefix. Within each test function, you can call functions from your code and use assert functions to check if the results are as expected.

- Running Tests:
After writing test cases, you can run them using the command line or integrate them into your build process. ExUnit will provide a detailed report on tests that passed and those that failed.

**Benefits of testing**

When you write tests in Elixir, you reap several benefits:

- Early problem detection: Tests allow you to identify issues before they affect production. By writing comprehensive test cases, you can uncover bugs and logic errors before they impact other components of your system.

- Simplified maintenance: Tests act as living documentation of your code. When you need to make changes to a code snippet, you can run the tests to ensure that the changes do not affect the existing behavior.

- Reliability: With well-written tests, you can have confidence in your code. When making changes or adding new features, you can run tests to verify that everything continues to function as expected.

Testing is essential to ensure the quality and reliability of your code in any programming language. With ExUnit and its solid framework, writing tests in Elixir becomes a straightforward and efficient task. By adopting testing in your development workflow, you can build robust and reliable systems. So, don’t hesitate to explore the testing features in Elixir and take your code to the next level!
Be Cheap! Get Free-Tier Hosting Service For Your Apps.
Tags: hosting, cloud, free
Published: 2023-06-29 21:29:00

---
title: Be Cheap! Get Free-Tier Hosting Service For Your Apps.
published: True
description: Finding free-tier hosting services is not easy. This blog can help you out. 
tags: ["hosting", "cloud", "free"]
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/axivopic2zhmpelhzipi.jpg
published_at: 2023-06-29 21:29 +0000
---

Got an app to try online, be cheap! Here some findings for hosting solutions in 2023... before they break their promise and turned to be a paid service.

(Links at the end)

There are great alternatives out there that offer free-tier plans for developers. Here are a few options worth exploring:

1. Render: Managed databases, static site hosting, and automatic SSL certificates.

2. Cyclic.sh: Deploy with Your Git.

3. Deta: Quickly building "personal spaces".

4. Fly.io: Global edge network across different locations.

5. PythonAnywhere: Beginner-friendly environment for Python.

Remember, choose free-tier hosting solution that fits your needs which allows you to continue testing, iterating, and growing your projects without breaking the bank.


![Free hosting meme](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cdekju2fwpp8fb784rx8.png)

Links:

https://render.com/pricing
https://www.cyclic.sh/pricing
https://deta.space/
https://fly.io/
https://www.pythonanywhere.com/

And bonus ...
https://freestuff.dev/tags/hosting/