teleren/devto huggingface dataset:
Update : my gamedev journey
Tags: gamedev, programming, design, beginners
Published: 2024-05-04 16:04:12

**Hello everyone**,

Remember that post I made a while back about how much I missed game development? Well, I've got an update for you!😌

Since then, I've taken the plunge and after finally finishing my Unity course, I've started a new game project using Unity. So far, it's been an exhilarating journey. Not only am I immersing myself in the challenges of conceptualization, but I'm also exploring the world of pixel art, which is a refreshing creative outlet, allowing me to have that feeling of really chilling out with some nice music and just designing my tileset. Of course, I'm aware that nothing is perfect!

Despite the heavy workload of my master's degree in software development engineering and architecture, as well as my work-study placement, I decided to devote some time to this passion project. It's not easy to reconcile school projects and game development, especially with school deadlines looming until July, but I'm determined to see this game through.

I'm finding it hard to juggle all this, and I have to admit I'm worried that all this work at school is going to put a barrier in the way of my project, or even make it run out of steam. I wanted to share this update with you all, hoping to get back to you in a few months with some positive news ahah

I hope you're all doing well and finding joy in everything you do. Stay safe! 😌

I wish you all the best of luck,
Bertrand

Previous post : https://dev.to/bertrand2808/miss-you-game-dev-1g9j
A Journey in DevOps Education
Tags: devops, cloud, linux, jenkins
Published: 2024-05-04 15:31:30

In today's tech-driven world, continuous learning is imperative, especially in fields like DevOps, where innovation and efficiency are paramount. For many, mentorship programs serve as invaluable platforms for honing skills and gaining real-world insights. One such program making waves in the tech community is the Nexascale Mentorship Program, designed to equip aspiring DevOps professionals with the tools and knowledge necessary for success.

My journey with the Nexascale DevOps Mentorship Program has been nothing short of transformative. The guidance and support provided by the program have helped me move forward at an unprecedented pace. The program focused on introductory topics such as DevOps principles, Linux OS, Git, and Jenkins, has laid a solid foundation for my understanding of essential concepts and technologies.

One of the standout features of the Nexascale DevOps Mentorship Program is its emphasis on practical learning. Through hands-on exercises and real-world projects, I've had the opportunity to apply theoretical knowledge in tangible scenarios, fostering a deeper understanding of key concepts. Working on tasks like setting up Git repositories, and configuring Jenkins pipelines has not only enhanced my technical proficiency but also instilled confidence in my abilities as a DevOps practitioner.

Moreover, the mentorship aspect of the program has been invaluable. Having access to experienced industry professionals who are passionate about nurturing talent has been a game-changer. Their insights, guidance, and personalized feedback have been instrumental in my growth journey, offering perspectives that transcend textbooks and online tutorials. The mentorship sessions, characterized by open dialogue and constructive critique, have fostered a supportive learning environment conducive to exploration and experimentation.

However, no program is without its areas for improvement, and the Nexascale DevOps Mentorship Program is no exception. Enhancing the program's networking opportunities could enrich the learning experience. Facilitating interactions between mentees and professionals from diverse sectors of the tech industry could open doors to collaboration, mentorship, and career opportunities beyond the program's duration.

In conclusion, my experience with the Nexascale DevOps Mentorship Program has been immensely rewarding, equipping me with the knowledge, skills, and confidence to navigate the dynamic landscape of DevOps. While the program excels in its structured curriculum, practical approach, and mentorship framework, there are opportunities for enhancement, particularly in expanding the scope of topics covered and fostering greater networking opportunities. Nevertheless, the program stands as a testament to the power of mentorship in empowering the next generation of DevOps professionals, and I am grateful to be a part of this journey toward excellence.
Onboarding as a Senior Engineer
Tags: eng, onboarding, process
Published: 2024-05-04 15:13:40

A 30/60/90 days plan is a valuable framework to use for a smooth landing in your new company. 

This suggested 30/60/90 day engineering onboarding plan is designed to ensure your successful transition as a new team member. Getting connected, delivering consistently and getting involved to best contribute to the company's goals.

Whether you are a manager welcoming new team member or an engineer starting in a new team, you can increase your chances of a successful onboarding by adopting this practice.

[Read more on my blog](https://www.jeromethibaud.com/en/blog/onboarding-senior-engineer/)
Portfolio/Resume Website builder with Accounting
Tags: webdev, programming, career, computerscience
Published: 2024-05-04 15:08:09

hi everyone,
my name is israr and i am founder of [WoBooks.com](https://wobooks.com).

## why i have created [WoBooks](https://wobooks.com) ?

finding a good web developer and creating website is not easy for everyone.
creating a website might not be a problem for businesses, but development/hosting cost is problematic for entrepreneurs/freelancers.

that's why people are going for no code development tools like [wix](https://wix.com) or [squarespace](https://squarespace.com) and few other too.

## Challenges and problems

startups and freelancers often struggle with limited funds. that's why they prefer using no code tools rather then buying expensive hosting etc. However, creating a website in these tools requires a certain set of skills and knowledge.

sometime startups/entrepreneurs/freelancers don't require/need specific functionality provided by no code tools or custom built website, they just want cheaper prices and want up and running in no time.

as for freelancers, they should have a resume website so they can share their education, work history and portfolio.

for small businesses, they can have a website with multiple themes to show their content, business information

## why [WoBooks](https://wobooks.com) is unique :

1. it includes double entry accounting system and invoice system.
2. hosted website in no time, with multiple themes.
3. blog for publishing content.
4. can be used for multiple teams/franchises under one dashboard

All you need to do is register, create team and pick a theme that fits your needs. You can choose to go with the ones that are prebuilt or your can get a custom theme built for you.

this save you a lot of money, and it will also minimize the risks associated, like outsourcing a website development project.


## Final words

there is not a single service that provides accounting/inventory/blog/inquiry system with website. 

for all the challenges that entrepreneurs/startups/freelancers face in their early stages, i tried to fulfill their needs in cheaper costs. 

with wobooks you can create a website without knowing how to code. and you can also manage your accounting needs.
I've tried to make it cheaper so every entrepreneur/freelancer can have their online presence in only $1 and connect their domain too.



suggestions/improvements and guidance would be really appreciated :)
TASK3
Published: 2024-05-04 15:02:59

TASK 3:
1.MODELS OF SDLC:
·  	Waterfall model
·  	Agile model
2.STLC- SOFTWARE TESTING LIFECYCLE
·  	Requirement analysis: checking all the requirements.
·  	Test planning: checking for number of tester needed, what tools and technologies to be used, checking memory size , etc.
·  	Test case development : tester should write all possible test cases to test the app.
·  	Test environment setup : every server has its own database , testing is based on it.
·  	 Test execution : checking pass and fail test cases.
·  	 Test closure : checking for all bugs that has to be cleared and closed.
 
3. RISK FACTORS OF TEST PLAN OF APP:
·  	Number of tester needed to check the app,
·  	what are the tools and technologies to be used,
·  	checking memory size the app occupies,
·  	delivering on time

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x87vca3xzbqeznarszoo.png)
TASK2
Published: 2024-05-04 14:59:45


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

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uznj4hyhscd7ndnz38qb.png)
git switch and git restore, or why not using git checkout
Tags: programming, tutorial, git
Published: 2024-05-04 14:58:56

`git checkout` command exists since the beginning of `git`

It is used for these things:

- creating new branch

   `git checkout -b new-feature upstream/main`

- switching branch

   `git checkout main`

- restoring unstaged changes

   `git checkout README.md`

- checking out code from other branch

   `git checkout v1.0.0 -- README.md`


`git checkout ` command confuses everyone who start using `git`

Why?

Because it mixes two concepts:
- branches juggling
- restoring files

That's why new commands were added with Git 2.23 (August 2019, **almost 5 years ago**):

- [git switch](https://git-scm.com/docs/git-switch): for playing with branches
- [git restore](https://git-scm.com/docs/git-restore): for restoring files.

git restore can be used as a simple replacement on action on files.

the only noticeable changes between git switch and git checkout is that branch creation was done with `git checkout -b name` while it's now `git switch -c name `


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

Credit: https://twitter.com/_risacan_/status/1162539626373865472
TASK 1
Published: 2024-05-04 14:49:58

TASK 1:
1.DIFFERENT TYPES OF TESTING:
·  	Black box testing
·  	Functional testing
·  	White box testing
·  	Grey box testing
·  	UI / GUI testing
·  	Compatibility testing
·  	Cross browser testing
·  	Smoke testing
·  	Sanity testing
·  	Regression testing
·  	Exploratory testing
·  	Monkey testing
2.STLC PHASES:
·  	Requirement analysis
·  	Test planning
·  	Test Case Development
·  	Test Environment Setup
·  	Test Execution
·  	Test Closure
3.Manual tester qualities:
   Check for the requirements details ,
   Analyse the requirements ,
	Critical thinking skill ,
	Check for the possibility of positive and negative scenarios,
	Check every part of module,
	Check with end user point of view.
	While testing newly developed software or application eg: myntra
	Tester has to perform all the possible positive and negative scenarios
	and look for bugs that has to be rectified.
4. Waterfall and agile model:
 
Waterfall model
Agile model
 
·  	Done once the complete development is done.
·  	It never welcome the change.
 
 
 
·  	The testing of features is done parallely .
·  	It always welcomes the change. The change happens in timely manner.
How to remove last character from string in JavaScript
Tags: javascript, beginners, tutorial, webdev
Published: 2024-05-04 14:44:47

There are many scenarios where you may need to remove the last character from a string. For example, you may want to:

- Remove a trailing slash or comma from a URL or a list
- Remove a newline or carriage return character from a text file
- Remove a punctuation mark from a sentence or a word
- Remove a digit or a letter from a number or a code

In JavaScript, common approachs are to use the [`substring()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) or [`slice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice), which allow you to extract a portion of a string based on the starting and ending indices. By specifying a range that excludes the last character, you effectively remove it from the string.

## Using slice method

The [`slice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice) method of String is used to extract a part of a string and return it as a new string, without modifying the original string. You can specify the start and end indexes of the extracted part, or use negative indexes to count from the end of the string.

```js
let str = "Hello world!";
str = str.slice(0, -1);
console.log(str); // "Hello world"
```

Here `slice(0, -1)` removes the last character because `-1` means the last index of the string. You can also use `str.length - 1` instead of `-1` to get the same result.

## Using substring method

The [`substring()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring) method of String is used to return a part of the string from a start index to an end index, excluding the end index. It does not change the original string, but returns a new string.

```js
let str = "Hello world!";
str = str.substring(0, str.length - 1);
console.log(str); // "Hello world"
```

The `substring(0, str.length - 1)` method removes the last character because `str.length - 1` is the last index of the string. You cannot use negative indexes with `substring()`.

## Using replace method

The [`replace()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace) method returns a new string with one, some, or all matches of a pattern replaced by a replacement. The pattern can be a string or regular expression, and the replacement can be a string or a function called for each match.

```js
let str = "Hello World!";
str = str.replace(/.$/, "");
console.log(str); // "Hello World"
```

The `.` within the regular expression represents any character, and the `$` denotes the end of the string. So, `.$` matches the last character in the string. By replacing it with an empty string, that character is removed.

Please note that if the string contains newline characters or multiple Unicode code points, the regular expression approach may not behave as expected. In such cases, using `substring()` or `slice()` methods might be more suitable.
A simple, cross-platform, and well-tested version manager for multiple SDKs.
Tags: nvm, fnm, gvm, sdkman
Published: 2024-05-04 14:43:05

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

Github: https://github.com/gvcgo/version-manager
Docs: https://gvcgo.github.io/vmrdocs/#/

**VMR** is a simple, cross-platform, and well-tested version manager for programming languages and tools. It is totally created for general purpose.
React Native Kakao (Good example for Monorepo, New/Old Arch, Expo, Web supporting package)
Tags: reactnative
Published: 2024-05-04 14:34:03


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

[React Native Kakao](https://github.com/mym0404/react-native-kakao) is an open-source library that ports the Android, iOS, and Web Native SDKs provided by Kakao, a major tech platform company in South Korea, for React Native.

Initially modeled after the structure of React Native Firebase, it has evolved to offer a vast supporting area.

The platform adheres to the same API for requests and responses on Android, iOS, and Web.
It even maintains consistency in the format of error objects for error handling.

Additionally, the architecture supports both the New Architecture (Turbo Module) and Old Architecture (Paper) as first-class citizens.

Furthermore, Expo integration is made easy as each module has an Expo config plugin.

While people not Korean may not necessarily use Kakao's SDK, you can explore the library's code as an example of building a library that guarantees such vast support.

This library is monorepo(using lerna-lite) and it can be a good help for who plan to support packages as a monorepo

Thank you.
WebAPI com .NET Consumindo ServiceLayer SAPB1
Tags: sapb1, dotnet, developer
Published: 2024-05-04 14:08:32

A ideia desse post é mostrar uma API desenvolvida em .NET Core consumindo a Service Layer do SAP. No cenário descrito, é utilizado o SAP B1.
Service Layer é um serviço do SAP onde é possível consumir as funcionalidades do SAP, como visualizar/cadastrar usuários, pedidos de vendas/compras, itens, etc. Os endpoints disponíveis podem ser visualizados nesse link:
https://help.sap.com/doc/056f69366b5345a386bb8149f1700c19/10.0/en-US/Service%20Layer%20API%20Reference.html

É um serviço muito interessante mas ele tem algumas peculiaridades tais como a necessidade de realizar um login prévio para que os endpoints possam ser consumidos e também a resposta para requisições GET possuírem no máximo 20 registros. Segundo a documentação, esse é o valor padrão para não afetar a performance pois dependendo da empresa, alguns serviços podem ter vários registros.
Mas isso pode ser um problema para certas ferramentas que não trabalham bem com requisições que necessitem de login e também para sistemas que precisam de todos os registros cadastrados. Por isso uma solução seria desenvolver uma API para consumir os serviços. Assim é possível manipular esse cenário.
Para resolver essa situação, o cenário desenvolvido seria como mostrado na imagem.


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

O funcionamento do cenário então se dá no seguinte: a aplicação chama a API, que fica responsável pelo login, manipulação da quantidade de registros e envio do token que será utilizado nas requisições. A API terá a responsabilidade de consumir os endpoints do SAP. Este retorna o resultado para a API desenvolvida e esta retorna o resultado para a aplicação. Com a API desenvolvida é possível manipular a quantidade de registros já que é uma informação que é necessária ser enviada no header.

Com a API rodando, ela está documentada com o Swagger conforme mostrado abaixo.


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

Na API desenvolvida, foi utilizada apenas o cenário de busca de itens. Mas é possível adaptar para qualquer outro cenário utilizando um dos endpoints oferecidos pelo SAP conforme link acima. Basta apenas criar suas rotas específicas com suas respectivas classes. 
Abaixo segue a API rodando buscando todos os itens.


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

O repositório da API pode ser consultado no link: https://github.com/WraSouza/sap_api

Qualquer contribuição sempre será bem-vinda.

Obrigado pela leitura.
How to Visualize RRT* Algorithm
Tags: ai, opensource, algorithms, beginners
Published: 2024-05-04 14:07:56

{% cta https://www.rerun.io/viewer?url=https://app.rerun.io/version/0.15.1/examples/rrt-star.rrd %} Try it in browser {% endcta %} {% cta https://www.rerun.io/examples/robotics/rrt-star %} Source Code {% endcta %} {% cta https://www.rerun.io/examples %} Explore Other Examples {% endcta %}

This example visualizes the path finding algorithm RRT* in a simple environment.

The algorithm finds a path between two points by randomly expanding a tree from the start point. After it has added a random edge to the tree it looks at nearby nodes to check if it's faster to reach them through this new edge instead, and if so it changes the parent of these nodes. This ensures that the algorithm will converge to the optimal path given enough time.

A detailed explanation can be found in the original paper Karaman, S. Frazzoli, S. 2011. "Sampling-based algorithms for optimal motion planning". or in this medium article.

# Logging and visualizing with Rerun

All points are logged using the `Points2D` archetype, while the lines are logged using the `LineStrips2D`.

The visualizations in this example were created with the following Rerun code:

---

## Map 

### Starting point 

```python
rr.log("map/start", rr.Points2D([start_point], radii=0.02, colors=[[255, 255, 255, 255]]))
```

### Destination point 

```python
rr.log("map/destination", rr.Points2D([end_point], radii=0.02, colors=[[255, 255, 0, 255]]))
```

### Obstacles 

```python
rr.log("map/obstacles", rr.LineStrips2D(self.obstacles))
```

---


## RRT tree 


### Edges 

```python
rr.log("map/tree/edges", rr.LineStrips2D(tree.segments(), radii=0.0005, colors=[0, 0, 255, 128]))
```

### New edges 

```python
rr.log("map/new/new_edge", rr.LineStrips2D([(closest_node.pos, new_point)], colors=[color], radii=0.001))
```

### Vertices 

```python
rr.log("map/tree/vertices", rr.Points2D([node.pos for node in tree], radii=0.002), rr.AnyValues(cost=[float(node.cost) for node in tree]))
```

### Close nodes 

```python
rr.log("map/new/close_nodes", rr.Points2D([node.pos for node in close_nodes]))
```


### Closest node 

```python
rr.log("map/new/closest_node", rr.Points2D([closest_node.pos], radii=0.008))
```


### Random points 

```python
rr.log("map/new/random_point", rr.Points2D([random_point], radii=0.008))
```

### New points 

```python
rr.log("map/new/new_point", rr.Points2D([new_point], radii=0.008))
```

### Path 

```python
rr.log("map/path", rr.LineStrips2D(segments, radii=0.002, colors=[0, 255, 255, 255]))
```

---

## Join us on Github
{% github https://github.com/rerun-io/rerun %}
Why Can't You SSH from an External Network?
Tags: linux, networking, beginners
Published: 2024-05-04 14:02:23

As long as keys are all right, SSH connectivity issues often have to do with networking and firewall configurations. To ensure SSH connections can be properly established from an external network, you need to configure port forwarding and firewall rules.

**Steps to Enable Port Forwarding and Allow SSH on Firewall**

**1. Retrieve Local IP Address**

To find the local IP address of the server, run the following command:
`ip addr`

_Now log in to your router. Please note that the steps below might vary depending on your router's vendor. I have a TP-Link router, so that's where I referenced from._

**2. Retrieve MAC Address of the machine**

- Go to _DHCP_ and select the _DHCP client list_.
- Find the server's IP address and its corresponding MAC address. Make a note of this MAC address.

**3. Add Server IP to Address Reservation**

- In the _DHCP_ section, select _Address Reservation_.
- Click _Add New_, enter the MAC address and the server's IP address, then click _Save_. Doing this step, so server's local IP address stays the same.

**4. Configure Port Forwarding**

- Go to _Forwarding_, select _Virtual Server_, and click _Add New_.
- Set _Service Port_ to _22_, IP address to the server's IP, and Internal Port to _22_. Click _Save_.

**5. Allow SSH Through the Firewall**

Even if SSH is installed and running on the server, it might not be allowed by the firewall. To permit SSH traffic through the firewall, use the following command:
`sudo ufw allow ssh`

**6. Allow SSH Traffic on External Firewall**

In a work environment, there'll likely be both a router and a firewall. Depending on the firewall vendor, the instructions may differ. However, add a rule to allow traffic from the host machine to the server on port 22 to ensure the firewall doesn't block SSH traffic.

**7. Connect to the Server from an External Network**

To establish an SSH connection, use this command:
`ssh -i keylocation/keyname user@publicIP`

Don't know your public IP? Just google what's my IP.
Simple DevOps Project on OpenStack Cloud
Tags: devops, openstack, jenkins, devopsproject
Published: 2024-05-04 14:00:26

[Complete Tutorial](https://www.linkedin.com/posts/sumonpaul_simple-devops-project-on-openstack-cloud-activity-7192246577896292353-vkd0?utm_source=share&utm_medium=member_desktop)