teleren/devto huggingface dataset:
User stories
Tags: webdev, agile, scrum, userstories
Published: 2023-07-26 15:50:35

**Welcome back** to our app development journey! In the previous blog posts, were the initial steps of ideation, approval, and project setup. Now, we're diving into the heart of the development process: breaking down our Minimum Viable Product (MVP) into user stories, estimating story points, prioritizing tasks, and getting hands-on with development. Let's explore these crucial steps to ensure the successful realization of our app idea.

To effectively develop our MVP, we started by breaking it down into smaller, manageable user stories. Each user story represents a specific functionality or feature that provides value to the end-user. By dissecting the MVP into these atomic units, we gain better visibility into the scope of work and ensure a focused approach to development.

Next, we documented detailed story descriptions for each user story on our GitHub board. These descriptions clearly define the user's goal, the functionality to be implemented, and the expected outcome. A well-written story description ensures a shared understanding among team members and reduces the chances of miscommunication during the development process.

To gauge the effort required for each user story, we employed a story point estimation technique. Team members collectively assigned story points based on complexity, technical challenges, and overall effort required for implementation. Story points are relative values that help us prioritize tasks efficiently and identify the most significant challenges within our MVP.

After estimating the story points, we prioritized the user stories based on their importance and value to the MVP. Critical features or those that significantly impact the user experience received higher priority. Prioritization ensures that we focus on delivering the most valuable features first, increasing the MVP's potential to meet user needs and expectations.
Top 10 AI Tools Every Developer Must Know in 2023
Tags: blog, developmenttrends, aitools, nearshoredevelopers
Published: 2024-06-28 15:46:00

---
title: Top 10 AI Tools Every Developer Must Know in 2023
published: true
date: 2023-07-26 15:46:53 UTC
tags: Blog,DevelopmentTrends,AITools,nearshoredevelopers
canonical_url: 
---

In today’s fast-paced and competitive world of software development, efficiency and effectiveness are more important than ever. As a nearshore software developer, you must adapt and learn to leverage modern tools to stay ahead of the game. To help web developers and web designers make the most of emerging tech, we have compiled a list of the top AI tools for nearshore developers in 2023. In this article, we will review these AI tools and how you can use them to work smarter.

The post [Top 10 AI Tools Every Developer Must Know in 2023](https://blog.nextideatech.com/top-10-ai-tools-every-developer-must-know-in-2023/) appeared first on [Next Idea Tech Blog](https://blog.nextideatech.com).
Link vào nhà cái NET88 - Nhà cái uy tín hàng đầu hiện này
Published: 2023-07-26 15:43:33

https://linknet88.com/ Link vào nhà cái NET88 mới nhất không bị chặn✔️ Link NET88 nhà cái uy tín số 1 Việt Nam✔️ Cá cược thể thao✔️ game casino đổi thưởng cùng NET88✔️✔️✔️
0943566165
66 Võ Văn Ngân, Phường Bình Thọ, Thành phố Thủ Đức, Thành phố Hồ Chí Minh
https://www.provenexpert.com/linknet88/
https://www.slideshare.net/linknet88
https://www.scoop.it/u/linknet88
https://www.scribd.com/user/680738152/Link-vao-Net88
Unveiling the Power of Stored Procedures and Functions in MSSQL: A Journey through the Enchanting Realm of Database Magic
Published: 2023-07-26 15:42:49

Welcome, data enthusiasts! Today, we embark on an exciting adventure in the world of Microsoft SQL Server (MSSQL). Let's dive into two powerful tools: Stored Procedures and Functions!

1. Stored Procedures: Your Versatile Spellbook!

Think of stored procedures as a magical spellbook, containing precompiled T-SQL incantations that you can summon at will. These reusable blocks of SQL sorcery bring a world of modularity and code reusability to your fingertips! No need to repeat code - just call on the stored procedure, and voilà!

With stored procedures, you can weave intricate business logic and bend data to your will with ease. They handle complex tasks like a seasoned sorcerer, and their mastery over transactions and errors makes batch processing a breeze!

2. Functions: Graceful Enchantments for Data Transformation!

Meet the elegant and versatile functions! These enchanting charms are like mini-spells designed for specific data transformations and calculations. Need to convert values or perform intricate computations? Functions are your loyal companions! They elegantly return single values, making your queries a breeze to read and understand.

While they might not wield the same transactional powers as stored procedures, their in-line usage within queries makes them graceful allies in your SQL adventures!

🧙‍♂️ The Magic Showdown: Stored Procedures vs. Functions!

Stored procedures and functions may seem similar, but their specialties set them apart.

Stored procedures rule when it comes to handling complex business logic and data manipulation. They're your go-to magicians for performing batch operations and ensuring data security.

Functions, on the other hand, excel at data transformations and calculations. They seamlessly integrate into queries, turning your data into enchanting results with ease!

🌟 The Right Tool for the Right Task:

When you face formidable foes and need to tackle complex data quests, call upon the might of stored procedures! Their modularity and transaction-handling prowess will serve you well.

For graceful data transformations and calculations, trust the charm of functions! Their in-line magic will keep your queries clear and your results spellbinding!

Conclusion: Unleash the Magic of MSSQL!

Fellow data adventurers, you now possess the secrets of stored procedures and functions! Whether you wield the power of stored procedures or embrace the elegance of functions, remember to use them wisely and make the most of Microsoft SQL Server's enchanting capabilities. Happy sorcery! 🧙‍♀️. Check out more from : https://lnkd.in/gSYr5RzY .
newSingleThreadContext() causes outofmemoryexeception in my service on Android
Tags: kotlin, kotlincoroutines, thread, kotlinandroid
Published: 2023-07-26 15:30:12


I am using *newSingleThreadContext()* to create a work and a arch threads. And I get outofmemory exception. 

Here is the code : "sampleId" is called everytime we change a parameter and this is implemented to throttle spamming of parameters to a test-library. Where we execute parameters sequentially instead of parallel.

package com.my.app.extension

import com.my.app.datastore.ParamValue
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock


suspend fun <T> Flow<T>.waitForTrue(stateFlow: StateFlow<Boolean>): Flow<T> {
    return flow {
        stateFlow.first { it }
        this@waitForTrue.collect(this)
    }
}

/**
 * Sample unique id and only return after a waiting time defined
 * @param periodMillis The time we wait to return if we get lots of calls in ms
 * @param waitMillis The time before next execution in ms
 */
@DelicateCoroutinesApi
fun Flow<Pair<String, ParamValue?>>.sampleId(
    periodMillis: Long,
    waitMillis: Long = 100
): Flow<Pair<String, ParamValue?>> =
    channelFlow {
        val hashMap = hashMapOf<Int, HashMap<String, Pair<String, ParamValue?>>>()
        var hasBeenActivated = false
        var activated = false
        var task: Deferred<Unit>? = null
        val mutex = Mutex()

        fun process() {
            if (!hasBeenActivated) {
                hasBeenActivated = true
                launch(newSingleThreadContext("work")) {
                    while (activated) {
                        delay(periodMillis)
                        mutex.withLock {
                            // hashmap operations.
                        }
                    }
                    hasBeenActivated = false
                }
            }
        }

        launch(newSingleThreadContext("arch")) {
            collect { item ->
                activated = true
                task?.cancel()
                task = async {
                    delay(waitMillis)
                    activated = false
                }
                mutex.withLock {
                    item.second?.let {
                        // hashmap operations.
                    }
                }
                process()
            }
        }
    }

I have tried to use different APIs of kotlin-android like newSingleThreadExecutor().asCoroutineDispatcher(), also used "use" call to free up the resource used like this

val context = newSingleThreadContext("worker")
                    context.use {
                        launch(context) {
But for some reason those parameter updates are not sent to the test-library at all.

I need some kind of mechanism where I do not get this outofmemory exception(by releasing threads after each iteration or something) and also the parameter updates are sent to the test-library.
#VSCode – Create and use Code Snippets 🗒️ in @code
Tags: englishpost, codesnippets, visualstudiocode
Published: 2023-08-02 14:47:05

---
title: #VSCode – Create and use Code Snippets 🗒️ in @code
published: true
date: 2023-07-26 15:15:49 UTC
tags: EnglishPost,CodeSnippets,EnglishPost,VisualStudioCode
canonical_url: 
---

Hi!

Code Snippets are super useful and creating your custom Code Snippets is super easy in Visual Studio Code. The official Documentation (see references) explains how to create snippets, with the full details of the JSON file, sections, contents and more. However, there are some extra tips on top of this information that are super useful.

## Snippet Creator

I moved from using Visual Studio Code Extensions to using this website.

#### [https://snippet-generator.app/](https://snippet-generator.app/) 

Just paste your piece of code and copy the generated JSON!

![sample of the website generating code snippets](https://brunocapuano.files.wordpress.com/2023/07/image-7.png?w=1024)

## Workspace or Folder specific snippets

Now it’s time to use our snippets, so let’s save them in a json file. To do this, just create a file [mysnippets.code-snippets] and paste your own snippets here. These snippets will only be available for this workspace!

![snippets for a workspace](https://brunocapuano.files.wordpress.com/2020/09/snippets-for-a-workspace.png?w=1024)

Happy coding!

Greetings

El Bruno

More posts in my blog [ElBruno.com](https://www.elbruno.com).

More info in [https://beacons.ai/elbruno](https://beacons.ai/elbruno)

* * *

## References

- [Snippets in Visual Studio Code](https://code.visualstudio.com/docs/editor/userdefinedsnippets)
- [Microsoft Docs – Code Snippets](https://docs.microsoft.com/en-us/visualstudio/ide/code-snippets?view=vs-2022)
Logbook ; Teachings of web development (I)
Tags: webdev, javascript, programming
Published: 2023-07-26 15:11:52

## Abstract
I will write here what I learned from web development, and seal it in my memory in order to attempt the best to not forget it ever. Or if I do, come back here to re-learn it :)

### I. Login
When doing a login site you have four (AFAIK) states.

1. You log-in correctly; (200)
2. You log-in incorrectly; (401)
3. A CORS error happens; (403)
4. Server is unavailable; (503)
LiveView vs LiveComponent vs Component
Tags: elixir, phoenix, webdev
Published: 2023-07-26 15:10:05

The official documentation says:

- use [_Phoenix.Component_](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html) to compartmentalize/reuse markup
- use [_Phoenix.LiveComponent_](https://hexdocs.pm/phoenix_live_view/Phoenix.Component.html) to compartmentalize state, markup, and events
- use nested [_Phoenix.LiveView_](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.html) to compartmentalize state, markup, events, and error isolation

## Some Context

- `handle_params`: A function triggered in the parent LiveView with the url params.

- `mount`: A function triggered in the parent LiveView and LiveComponents for setting the initial values.

- `update`: A function triggered in the parent LiveView and LiveComponents for updating the assigns in a component instance.

- `preload`: A function triggered in the parent LiveView and LiveComponents for updating the assigns in multiple instances of the component.

- `handle_event`: A function triggered by the HTML/JS side.

- `handle_info`: A function triggered by using `send(self(), args)` inside a `live_component`. Handled by the parent liveview.

- `pipeline`: A function that is called when defining the live_view or live_component.

- `@myself`: A target to specify in LiveViews or LiveComponents. `phx-target={@myself}`

**lib/my_web/my_web.ex** 

```elixir
def live_view do
    quote do
      use Phoenix.LiveView,
        layout: {MyWeb.Layouts, :app}

      unquote(html_helpers())
    end
end
```

Used as 

```elixir
defmodule MyWeb.Live.Home do
  use MyWeb, :live_view
```

This is how I understand the main differences


## LiveView

- Creates a **socket**
- Handlers: `handle_event`, `handle_info`, `handle_params`, `mount`, `update`, `preload`.
- Can use `@myself` to handle events (requires id)
- Renders html

[live_render/3](https://hexdocs.pm/phoenix_live_view/Phoenix.LiveView.Controller.html#live_render/3)

## LiveComponent

- Uses the **socket** defined in the Parent _LiveView_
- Handlers: `handle_event`,`mount`, `update`, `preload`.
- Can use `@myself` to handle events (requires id)
- Renders html

```elixir
<.live_component module={MyModule} id="unique_id" {assigns} />
```

## Component
- Only renders html

```elixir
<MyComponent.render {assigns} />
```

## Comparison

| Item | LiveView       | LiveComponent          | Component  |
|---------| :-------------: |:-------------:| :-----:|
|renders html |✅ | ✅|✅
|can use `@myself` (requires id)| ✅      | ✅      |   ❌ |
|mount| ✅      | ✅      |   ❌ |
|update| ✅      | ✅      |   ❌ |
|preload| ✅      | ✅      |   ❌ |
|handle_event| ✅      | ✅      |   ❌ |
|handle_info| ✅ | ❌     |    ❌ |
|handle_params| ✅ | ❌     |    ❌ |
|creates a socket| ✅| ❌ | ❌ |
Free Xbox Gift Card Generator 2023 Free
Published: 2023-07-26 14:59:48

box Free Gift Card Code Generator without human verification.Free Xbox Gift Card Code Generator 2023.free xbox gift vouchers free xbox gift voucher codes how to get free xbox gift vouchers free xbox gift voucher codes 2023Xbox Live Free Gift Card Code Generator | 2023 (100% Working)


** 𝐂𝐎𝐏𝐘 & 𝐏𝐀𝐒𝐓 𝐋𝐈𝐍𝐊 𝐁𝐑𝐎𝐖𝐒𝐄𝐑👉 []**(https://bnidigital.com/xbox1)****


👈 Using our Xbox Live Gift Card CodeGenerator Tool you can Get limitless Free xbox Codes to buy limitless Stuff, You can Redeem itDirectly on microsoft. Microsoft which is Richest Company in the World has Lots of Products in The Market,Xbox Live is Also one of them Which is Home Based Gaming Network After Launched it has Come in parts ofVariants Such 360 , one and so on Free XBOX Gift Card Generator: To be straightforward talking, this free Xbox gift voucher generator acted the legend, when we required it themost. We were genuinely bewildered, and we were becoming aggravated too. Inthis way, appearance on this site wind up being a God-send favoring. Given the scores of fake free Xboxgi
Instantly Sync and Publish Notes with Teammates using Invio
Published: 2023-07-26 14:47:26


Working with teammates has never been simpler thanks to Invio's collaborative workflow. Save time by sharing configurations and directories with the click of a button.

[Invio Docs](https://docs.webinfra.cloud/Invio/index.html) is an Obsidian plugin that lets you easily publish notes as a self-hosted website while syncing changes with your team - all without server maintenance. Invio securely stores your data in AWS S3 or compatible cloud storage.

With Invio you can:

- Export your current directory's settings as a hash string

- Share the hash string with teammates

- Teammates import the settings with one click

- Invio syncs all files whenever a change is made


This single source of truth for your directory means:

- Simple onboarding for new team members
- Strong encryption keeps your data safe
- Easy editing and management of shared files


Give your productivity a boost:

- Effortlessly sync and publish notes
- Collaboratively edit your online documentation
- Securely store your data in the cloud

Try Invio's collaborative workflow today. Share your first workspace for free - Invio is open source.

View the GitHub repo: [Invio ↗](https://github.com/frontend-engineering/Invio)
Thrilled about tech: met multiple challenges and lessons. How did it end?
Tags: webdev, beginners, programming, css
Published: 2023-07-26 14:46:36

## Thrilled about Tech
Well as any newbie I started this week with some pretty exciting things going on: I completed my first fontendmentor challenge, felt pretty groovy about myself and I felt nothing was going to stop me. Until something unexpected happened..

## The challenges
I tried to merge a pull request on github and I had the dreaded "conflicts". I panicked a little; but I googled [how to fix git conflicts](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/addressing-merge-conflicts/resolving-a-merge-conflict-on-github) and I was able to resolve them with easy suprisingly enough.
So to you my fellow newbies: don't panic you don't know the answer right away or you are stuck. You are learning.It is part of the journey. Just reach out to people or the community for help.

## How it ends
Well There really is no end for now. I'm gonna keep coding no matter how I feel. And I'd encourage everyone who reads this to not stop if they have started.
Avoiding Pitfalls: Mitigating Risks in Cloud Migration
Tags: cloudcomputing, programming, webdev
Published: 2023-07-26 14:34:22

Serverspace on board! As you all know, cloud migration is a smart move for many businesses, but it comes with some risks. We created a simple guide to understanding and tackle these challenges for a smooth transition:


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

1. Keep your data safe during migration by choosing trusted cloud providers (like we are) with strong security measures. Use encryption and strict access controls to protect sensitive information.
2. Plan carefully to minimize downtime. Test everything thoroughly and have backup plans in case something goes wrong.
3. Check if your existing applications work well with the cloud. Update or refactor them if needed, and use cloud tools for seamless integration.
4. Watch out for unexpected expenses. Make a budget and use cost-monitoring tools to optimize spending.
5. Ensure your applications perform well in the cloud. Test for bottlenecks and optimize as necessary.

By addressing these risks, your cloud migration will be a success, and you can enjoy the benefits of a cloud-based environment for your business. Peace!
Why Every Startup Should Have a Comprehensive SRS for Software Development
Tags: startup, softwareengineering, architecture, productivity
Published: 2023-07-26 14:33:33

let’s explore why it is imperative for every startup to invest time and effort in crafting a comprehensive SRS before diving into software development. We will delve into the benefits, insights, and strategic advantages that arise from this crucial pre-development process. So let’s explore why writing an SRS is the cornerstone of a startup’s software development journey.

[Continue Reading](https://younisjad.medium.com/why-every-startup-should-have-a-comprehensive-srs-for-software-development-cb7042d9365a)
TIL Day 4 HTML and Ruby
Tags: html, ruby, css, beginners
Published: 2023-07-26 14:32:10

I decided to do some reflecting before moving forward on any of my assignments since it has been days since I last posted. Here are some recent learnings: 

- There is a difference between flex-items and flex-containers (obvious for me now). Flex-containers are elements whose display value property is an HTML element (often the parent element) whose display property's value is flex or inline-flex. Flex-items are the direct children of a flex-container (a parent element). 
- When working on the styling you should use the following hack to better see each element on the page: 
`* {
  border: thin red solid;
}`
- Ruby has built-in skills called methods which enables the interpreter to read and show you results within a console
- Ruby can do some neat computations: addition `+`, subtraction `-`, multiplication `*`, division`/`, exponents `**`, and modulo `%`. 
- Ruby allows for us to get user input by using `get.chomp`. Retrieving user input through this method felt very different in comparison to HTML, so I was initially thrown off but that's life.

Anyways, my first impression of Ruby is that it is a beast, but I am down for the challenge. I hope to keep trudging on through the Codecademy Ruby course these next couple days.
Day 12: Function Borrowing
Tags: day12, 100daysofcode, javascript
Published: 2023-07-26 14:00:00

## Understanding Function Borrowing:

Function borrowing enables us to use a method from one object and apply it to another object. This can be achieved by invoking a method from one object but setting the `this` keyword inside the method to point to a different object. It is accomplished through the use of `.call()`, `.apply()`, or `.bind()`, all of which exist to explicitly set this on the method we are borrowing.


- **call** method:

The `call()` method is used to invoke a function with a specified this value and arguments provided individually.

```javascript
functionName.call(thisArg, arg1, arg2, ...);
```
```javascript
const person1 = {
  name: 'Alice',
  greet: function(greeting) {
    console.log(`${greeting}, I'm ${this.name}.`);
  },
};

const person2 = {
  name: 'Bob',
};

person1.greet.call(person2, 'Hello');
// Output: Hello, I'm Bob.
```


- **apply** method:

The `apply()` method is similar to `call()`, but it takes an array-like object as its second argument to pass arguments to the function. 

```javascript
functionName.apply(thisArg, [arg1, arg2, ...]);
```

```javascript
const person1 = {
  name: 'Alice',
  greet: function(greeting, age) {
    console.log(`${greeting}, I'm ${this.name}, and I'm ${age} years old.`);
  },
};

const person2 = {
  name: 'Bob',
};

person1.greet.apply(person2, ['Hello', 30]);
// Output: Hello, I'm Bob, and I'm 30 years old.
```

- **bind** method: 

The `bind()` method creates a new function with a specified this value and any provided initial arguments. Unlike `call()` or `apply()` that executes the function immediately, bind() returns a new function that can be called later.
```javascript
const newFunction = functionName.bind(thisArg, arg1, arg2, ...);
```
```javascript
const person1 = {
  name: 'Alice',
  greet: function(greeting) {
    console.log(`${greeting}, I'm ${this.name}.`);
  },
};

const person2 = {
  name: 'Bob',
};

const greetBob = person1.greet.bind(person2, 'Hi');
greetBob();
// Output: Hi, I'm Bob.
```