teleren/devto huggingface dataset:
DevLog #6 - Customer collaboration in Agile development.
Tags: agile, development
Published: 2024-04-08 21:35:47

Customer collaboration in the development is crucial for agile methods. Since in every sprint, the development team delivers a working software, customers can implement it in the real world scenarios to check whether it suits their needs and can give feedback before the start of the next sprint. Then the development team has the possibility to add those changes into the backlog of the next sprint. Then sprint by sprint product will be fine-tuned towards the realistic customer requirements. Then work stress and risk will also be reduced on the development team. Likewise, if a customer can collaborate with the team, throughout the development phase in all sprints, it will help to deliver the finest outcome for customer requirements. 
As my point of view, in a development project, team needs to more focus on the customer feedbacks and suggestions regularly than written requirements documents.
Fashion
Published: 2024-04-08 21:35:11

VIDEO: AUTHENTISCHE KULINARISCHE ERFAHRUNG: BESTER JAPANISCHER SAKE

Die Craft Spirits Berlin Awards sind Europas wichtigster Wettbewerb für handwerklich hergestellte Spirituosen. Die eingereichten Produkte werden von einer 21-köpfigen internationalen Jury aus Experten und Sensorikern bewertet. Dabei wird ein one hundred-Punkte-Schema in Blindverkostungen angewendet, um Geruch, Geschmack, Ausgewogenheit und charakteristische Merkmale zu beurteilen.
**_[Fashion](https://www.modelvita.com/)_**
Je nach erreichter Punktzahl werden Gold-, Silber- oder Bronzemedaillen vergeben. In diesem Jahr wurden über 570 Produkte eingereicht. Als „Best in Class“, mit Gold und als bester Japanischer Sake wurde in diesem Jahr der Junmai Ginjo Go-Sake ausgezeichnet, von der Arimitsu Brauerei in Kochi.

„Wir freuen united states of americasehr über diese beiden Auszeichnungen und danken den 21 Jurymitgliedern und Craft Spirits Berlin für diese Ehre“, so Dr. Bastian Schwithal, Geschäftsführer Go-Sake.

Go-Sake mit Gold ausgezeichnet

JAPANISCHER SAKE ZUNEHMEND BELIEBTER
“Die steigende internationale Nachfrage nach authentischen kulinarischen Erfahrungen hat dazu beigetragen, dass japanischer Sake zunehmend beliebter wird. Letztendlich spiegelt die Popularität von japanischem Sake die Faszination der Menschen für die reiche Kultur und die Handwerkskunst Japans wider.“

Junmai Ginjo Sake ist ein spezieller Sake Typ, der durch einen bestimmten Herstellungsprozess definiert ist. „Junmai“ bezieht sich darauf, dass der Sake rein aus Reis hergestellt wird, ohne Zugabe von Alkohol oder Zucker.

„Ginjo“ bezeichnet eine Qualitätsstufe, die darauf hinweist, dass der Reis für den Sake in einem hohen Masse poliert wurde, um eine höhere Reinheit und Raffinesse zu erreichen. Junmai Ginjo Sake ist daher bekannt für seinen delikaten Geschmack, seine komplexe Aromenpalette und seine hohe Qualität.
Kotlin Multi-platform using Jetpack Compose for building desktop apps.
Tags: kotlin, opensource, github, tutorial
Published: 2024-04-08 21:32:29

Hey Folks!👋

I am happy to introduce **WallStreet**, The first free and OpenSource multi-platform Jetpack Compose wallpaper app. 

![WallStreet app thumbnail](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9bs5td1899zae3vtgx80.png)

> Long story short, If you're an Android developer then switching into multi-platform app using your existing skills will be a piece of cake.

## Context ✍️
To set some context, This is a simple Wallpaper app with a beautiful UI leveraging everything that JetpackCompose is capable of. While also posting original wallpapers that are being AI generated and fetched through a static API that has been hosted in Github itself, Just to give you an idea on how the API + app will work together. (Download the app and try it yourself to get the feel of it yourself 🫶)

**So, what's the big deal about this while there are many more wallpaper alternatives out there** 🤔
✅ Free & OpenSource
✅ Multi-platform compatibility (Windows, MacOS and Linux)
✅ You get to learn and get started with Kotlin MultiPlatform
✅ Performant, Responsive and Beautiful UI
✅ Original and Authentic wallpapers made with DALL-E 3 
✅ Contribute to Code or Collection of the Wallpaper

You'll get to learn more about this project by visiting the links posted below. The attached README should help you easily get started with it or even download for your desired platform and enjoy it!🙌🏽
While at it, If you liked the project and would show me some support, Do leave a **Star** behind✨

## Links 🔗
[WallStreet - Kotlin MultiPlatform Jetpack Compose app](https://github.com/StarkDroid/WallStreet)
[WallStreet API - The Wallpaper collection itself](https://github.com/StarkDroid/WallStreet-API)

### I highly appreciate any sort of contribution to the project 😄
How to enable GitHub Actions on your Profile README for a snake-eating contribution graph / Edit_DA_01
Published: 2024-04-08 21:24:43

Thanks **Michelle Mannering** for your (https://dev.to/mishmanners/how-to-enable-github-actions-on-your-profile-readme-for-a-contribution-graph-4l66) topic.

If other users wish to utilize this, kindly modify this topic;

1-Use this (thanks **Platane** https://github.com/Platane) file;

https://github.com/1SeaMy/1SeaMy/blob/main/.github/workflows/main.yml

2-Use this;


`![snake gif](https://github.com/YOUR_USERNAME/YOUR_USERNAME/blob/output/github-contribution-grid-snake-dark.svg)
`
or this


`![snake gif](https://github.com/YOUR_USERNAME/YOUR_USERNAME/blob/output/github-contribution-grid-snake.svg)
`
Running an Effective Agile Retrospective🔄
Tags: scrum, agile, webdev, productivity
Published: 2024-04-08 21:00:46

Agile retrospectives stand as a cornerstone of continuous improvement in agile teams, offering a structured method for reflecting on team performance and identifying actionable insights to enhance future sprints. However, navigating the intricacies of retrospectives to maximize their benefits can often be challenging.

In a recent exploration on Kollabe, the post [Running an Effective Agile Retrospective](https://kollabe.com/posts/running-an-effective-agile-retrospective) delves into practical strategies and insights for conducting retrospectives that not only engage team members but also foster an environment conducive to honest feedback and meaningful improvement.

The article emphasizes the importance of creating a safe space where team members feel comfortable sharing their thoughts and opinions. It suggests various techniques to ensure that retrospectives are inclusive and productive, such as using specific facilitation tools and methodologies that encourage participation from all team members.

**Key takeaways include:**

- Preparation and Structure: How to prepare for a retrospective that addresses the needs of your team and follows a clear, structured approach to discuss past sprints.

- Engagement Techniques: Innovative methods to engage team members, ensuring that everyone's voice is heard, and fostering a collaborative environment.

- Actionable Insights: Strategies for deriving actionable insights from the discussions, prioritizing them, and implementing changes in subsequent sprints.

Whether you're new to agile methodologies or seeking to refine your approach to retrospectives, this post offers valuable perspectives on making these sessions more effective and impactful.

For a deeper dive into running successful agile retrospectives, read the full article [here](https://kollabe.com/posts/running-an-effective-agile-retrospective).
Creating Custom Git Commands
Tags: git, terminal, commands
Published: 2024-04-08 20:56:19

---
title: Creating Custom Git Commands
description: Creating custom Git commands to help automate git workflow.
tags: 'git, terminal, commands'
canonical_url: null
published: true
---

![Blog Post Thumbnail](https://raw.githubusercontent.com/spencerlepine/blog/main/content/creating-custom-git-commands/thumbnail.jpg)

Every time I clone a repository from GitHub, I always run the same set of commands. This is prone to typos and simply inconvenient. There is a simple solution of combining each step into a single command that automatically runs everything for us.

In this example, I need to clone a GitHub repository, move into the new directory, and then open the project in VSCode.

Instead of multiple commands:
```sh
  git clone https://github.com/spencerlepine/readme-crawler
  cd readme-crawler
  code .
```
It would great to run one command:
```sh
	clone https://github.com/spencerlepine/readme-crawler
```

To achieve this, we can create a script in the ```~/bin``` directory. Make sure this path matches up with your configuration for the terminal (e.g. ```PATH=$PATH:$HOME/bin```).

Let’s create a custom script to combine the git commands.

```sh
  #!/bin/bash

  ((!$#)) && echo missing git URL argument! && exit 1

  git clone $1
  basename=$(basename $1)
  reponame=${basename%.*}
  cd $reponame
  npm install
  code .
```

Use this script or create your own, and follow these steps to set up the custom command:

- Navigate to usr/local/bin -> ```cd ~/../../usr/local/bin```
- Run ```vim clone```
  - *Paste the script*
- Save the file:
  - *press ‘ESC’
  - *press ‘SHIFT’ + ‘:’
  - *type ‘wq’ + ENTER
- Create an executable
  - ```chmod +x clone```
- Run the command!
  - ```clone https://github.com/spencerlepine/manyshiba-bot.git```

Viola! This script will accept one command line argument of the destination repo URL. It will automatically open the new project in VSCode in one command.

Follow my journey or connect with me here:
- LinkedIn: [/in/spencerlepine](https://www.linkedin.com/in/spencerlepine/)
- Email: [spencer.sayhello@gmail.com](mailto:spencer.sayhello@gmail.com)
- Portfolio: [spencerlepine.com](https://spencerlepine.com)
- GitHub: [@spencerlepine](https://github.com/spencerlepine)
- Twitter: [@spencerlepine](https://twitter.com/spencerlepine)
Linux Boot Sequence: Docker's Market Edge
Tags: docker, linux, containers, kubernetes
Published: 2024-04-08 20:31:51



![Linux](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4wabh4w2f0aej65d6n5k.png)
The Linux boot process and the lightweight Docker Linux boot serve different purposes and operate at different levels of abstraction, but they are related in the sense that both involve the initialization and setup of a Linux-based environment. Let's compare them:

1. **Linux Boot Process**:
   - The Linux boot process refers to the sequence of steps that occur when a computer system powered on or restarted.
   - It involves several stages such as BIOS/UEFI initialization, bootloader loading, kernel initialization, and finally, user-space initialization.
   - During this process, the Linux kernel is loaded into memory, and various system services and processes are started to bring the system to a usable state.
   - The Linux boot process typically results in a fully functional operating system environment where users can interact with the system through a command-line interface or a graphical desktop environment.

2. **Lightweight Docker Linux Boot**:
   - Docker is a platform for developing, shipping, and running applications in containers. Containers provide a lightweight and portable way to package and isolate applications and their dependencies.
   - When you start a Docker container, it doesn't involve the full Linux boot process described above. Instead, Docker leverages features of the Linux kernel such as namespaces and control groups (cgroups) to create isolated environments for running applications.
   - Docker containers start quickly because they don't need to boot a separate operating system instance. Instead, they reuse the host operating system's kernel and only include the necessary libraries and dependencies specific to the application being run.
   - Docker containers are lightweight and have minimal overhead compared to traditional virtual machines, making them ideal for deploying and scaling microservices and other cloud-native applications.

In summary, while the Linux boot process is concerned with bringing up an entire operating system environment from scratch, including all system services and processes, Docker's lightweight Linux boot involves quickly initializing isolated containers that leverage the host operating system's resources to run applications efficiently.

Stay tuned for my Podcast - "Under the Hood" to be hosted on Twitch, Discord and Youtube, coming out soon!
Unity UI Framework
Tags: unity3d, opensource, gamedev, programming
Published: 2024-04-08 20:24:39

Hello everyone. Today I want to present a small library for your Unity Games. **Unity UI Framework** - A set of tools for interface developers, ready to use in your projects and supporting the MVC/MVP/MVVVM patterns. The basic architecture works based on View and Layouts, and interaction is handled by an event system to make your interface logic independent.

**Toolkit Features:**
- Ready for MVP/MVC/MVVM;
- Views and Layouts loading from Scene / Resources;
- UI Controller for Views Management and Navigation;
- Binding / Unbinging Events;
- UI Particle System and UI Shaders;
- Simple Components Like Imaged Button and Web Image;
- Optimized for every platform;

**Dependencies and Requirements:**
- Unity 2019+;
- Unity Event Framework (included in project);
- Unity UI (UGUI);
- TextMesh Pro UGUI;

## Get Started
**Unity UI Framework** is designed for your application and games using **Unity UI** (UGUI) and support Unity 2019+.

**Installation process:**
- Download and import latest release [from this page](https://github.com/DevsDaddy/UIFramework/releases);
- See usage examples below;

**See Demo Scene to learn how it works (UIFrameworkDemo):**
![Unity UI Framework Demo](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/iv2d7vynp8bbhynd2hb2.png)

## How it works?
**The UI Framework** works according to the **View / Navigation / Layouts** scheme. And separates entities between them. Each screen or window is a View that is stored in history for navigation. Each View can have its own unlimited number of Layouts. One of the View must be the home View for navigation.

**For more info see Usage Examples or see Demo Scene. Also I recommend to see [One UI Kit](https://github.com/DevsDaddy/OneUIKit) based on UI Framework.**

## Simple Usage
**Views Binding:**
```csharp
UIFramework.BindView(Instantiate(homeView), true); // Home Page
UIFramework.BindView(Instantiate(pageView));       // Sub-Page
```

**Navigate to another view:**
```csharp
EventMessenger.Main.Publish(new OnViewNavigated {
    View = typeof(DemoPageView),
    Display = new DisplayOptions { IsAnimated = true, Delay = 0f, Duration = 0.5f, Type = AnimationType.Fade },
    Data = new DemoPageView.Data {
        Title = "Demo Page",
        Content = pageContent
    }
});
```

**Download latest version / Learn API reference:**
https://github.com/DevsDaddy/UIFramework

---

[My Discord](https://discord.gg/a7cHDtfYbv) | [My Blog](https://devsdaddy.hashnode.dev/) | [My GitHub](https://github.com/DevsDaddy) | [Buy me a Beer](https://boosty.to/devsdaddy)
Overcoming Tight Coupling In OOPs With Effective Solutions
Tags: springboot, spring, java, oops
Published: 2024-04-08 20:14:28

Familiar with "**tight coupling**" in OOPs? It's a common issue where classes become overly interdependent, making code changes cumbersome and error-prone. Imagine updating one class and having to revise multiple others due to tight dependencies. 

This is how a tightly coupled code looks like:

Here, the direct instantiation of **Engine** class within the constructor of **Car** class creates a strong dependency between the two classes.


![Tight coupled code](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3wpv8cjwwc020qgwv9z4.png)

The problem encountered in the above code can be solved using **Dependency injection** in Spring and by promoting the use of **Interfaces**.

**METHOD 1: Dependency injection using constructor injection**

**Problem** ❌: Tight coupling occurs when one class directly instantiates another class, using the “**new**” keyword

**Solution** 💡: Use Dependency injection to pass dependency from external sources, highly used in Spring . In the below figure the engine object is being passed as the parameter to the constructor from an external source.


![Solving tight coupling using dependency injection](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/saltogymi79118k8w8xl.png)

**METHOD 2: Using interfaces**

**Problem** ❌: Classes depending on  concrete implements rather than interfaces, causes tightly coupled relationship between them. To say,  if the type of engine to be used by a car is changed the whole code has to be re written again.

**Solution** 💡: Use interfaces instead of using concrete classes, this gives more flexibility to a code.


![Solving tight coupling using Interface](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qeb56njnfmotzkxh1wrz.png)



Follow [Me](https://dev.to/priyankachettri) for such contents!
Happy Learning :)
Uncaught Error: No QueryClient set, use QueryClientProvider to set one
Tags: webdev, react, vite, development
Published: 2024-04-08 20:12:21


Hello and welcome!

If you encounter an error while using `@tanstack/react-query` in your React Vite project, there's no need to panic. 
Check your imports related to React Query.

You might be using:

```
import { useQuery } from 'react-query';
```

Instead of:

```
import { useQuery } from '@tanstack/react-query';
```


YouTube [@catwebdev](https://www.youtube.com/channel/UC2pGphugSZ0Qp2zuXSOPx0g)

_Thank you for reading.
See you in the next one!_
How reading can make you a better developer
Tags: developer, beginners, productivity
Published: 2024-04-08 19:30:52


Have you ever had the feeling that everything has already been created by someone else? The world is big, and with the internet, we have the capacity to reach almost every piece of knowledge that has been produced by the human race.

But this has started a long time before the popularization of the internet; the sharing of information started with books. They were the first, and in my opinion, the most amazing form of technology created before. With books, you get the chance to access the minds of great people, people who dedicated their lives to learning one specific field, and we are fortunate enough that those people were kind enough to share those learnings with us.

Okay, I wonder that you are thinking something along the lines of: what is the point of all of this? How is this related to programming? Well, it turns out that programming is just a form of writing; while we are writing code, we are just talking to the computer to translate the requirements of our application to the computer.

So if we are writing things, sure enough, someone has already solved the problem that we are trying to solve, but how could we find this? Again, we are fortunate enough to have one of the major "libraries" of code open to us; we just need to read through it. Reading someone else's code is one of the main forms of learning for me. When I do that, I can understand not only the language that I'm learning/working with, but also how people who dedicated their lives to writing applications think. By reading their code, I can get a shortcut on how to solve the problems that I'm facing in a more efficient way without having to spend hours of my life thinking about that problem.

But life is not easy, and every approach has its problems, and over the years - I have been using this one for the past seven years, as a developer - I have faced some issues like: sometimes you are not able to frame your problem in a way that was solved before by someone else, and you have to figure this out by yourself. But interestingly enough, I used the principles of learning from others to create my own solution because, in the end, we, as a society, just exist because we are capable of learning from our peers. But while I was figuring things out with the learnings that I accumulated, I faced some anxiety, and those were addressed with exercises, help from friends, and psychotherapy.

Another issue that I saw people having is not being able to spend the needed time to let things work. The internet brings a lot of good things for us, but also a lot of distractions. And this approach doesn’t work with distractions. To learn by reading, you have to spare time to let things settle inside yourself. If you get distracted by your phone, you will not be able to let your brain do the work that is needed to sink that knowledge in.

Getting free from distraction and sparing time in the day to learn something is one of the foundations of a good life, a life without so much anxiety and more confidence in your endeavors.
security guard services los angeles
Published: 2024-04-08 19:18:00

In Los Angeles, the significance of security guard services cannot be overstated in ensuring the safety of various establishments. These services encompass a wide array of security solutions tailored to meet the needs of residential, [security guard services los Angeles](https://megacontrolsecurityservices.com/) commercial, and event venues. With a strong emphasis on training and utilization of cutting-edge technology, security companies in Los Angeles deploy highly skilled personnel to uphold safety standards. Their presence instills confidence and peace of mind among clients and the community, contributing significantly to maintaining security across the city.
Cardano (ADA) Breakout Signals: Brace for 32% Rally Ahead 🚀
Published: 2024-04-08 19:11:01



📈 Cardano (ADA) price is poised for a potential breakout, aiming for new year-to-date highs.

🐋 Cardano Whales' Impact: Recent data shows accumulation by addresses holding between 1 million and 10 million ADA, indicating a bullish sentiment among whales. This accumulation totaled nearly 50 million ADA worth $30.3 million, boosting their holdings to 5.79 billion ADA.

📉 Price-Daily Average Addresses (DAA) Divergence: The DAA divergence is currently signaling a sell signal as ADA's price rises while DAA drops. This divergence typically precedes short-term price rises, suggesting a potential bullish trend ahead.

🚀 ADA Price Prediction: ADA is forming a falling wedge pattern, a bullish reversal pattern often followed by a rally upon breakout. A successful breakout could lead to a 32.91% price increase, targeting $0.813. However, intensified selling sentiment could invalidate this pattern, potentially pushing ADA down to $0.500.

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