teleren/devto huggingface dataset:
First post - Introduction and Open Source exploration
Tags: opensource
Published: 2023-09-08 23:00:42

Hi! My name is Katie Liu, a third year student at Seneca College. This blog will showcase the work I do this term in my Open Source Development course, as well as any work I do for my personal open source projects :)

I am very excited to have the chance to use the programming skills I have learned in the last two years of school and co-op to contribute to open source projects. Open source attracted me because it has so much potential to grow and be widely used due to the fact that it is free and it is open to everyone around the world.

This term I hope to be able to help identify and fix bugs in some open source projects. Specifically I would like to tackle project in the languages which I am proficient in, such as C++, Java, JavaScript, or Python. I also have an interest in projects that offer web solutions to small business owners or the general population.

A GitHub trending repo that I researched on is called [astro](https://github.com/withastro/astro). Astro is similar to an SSG, but it is built for speed! It can build static websites with popular JavaScript frameworks (React, Vue, or use multiple frameworks) while shipping no JavaScript to the browser. You can use JavaScript frameworks to build your site, and astro renders them to static html at build time. If you have a component that is fully interactive with JavaScript, there are multiple ways to render and hydrate it at client-side. If a component is low priority, you and wait until the browser is idle before rendering it. You can also hold off on rendering a component that is lower down in the page, until it is visible to the user.

I picked astro because it has similarities to the SSG which I will be developing the coming two weeks. I may even do research on whether I can use astro to create my SSG.
Kafka in a Nutshell 🌰: Events, Topics, and APIs made simple
Tags: java, beginners, database, kafka
Published: 2023-09-08 22:50:16

# Intro
For many years, our default method for data storage has been databases, which have effectively served us for decades.

However, in certain cases, it might be more beneficial to focus on events rather than static data.

## Events

So, what exactly is an event? An event is a timestamped indication that a specific action has occurred.

Traditionally, storing events in databases can be a tad inefficient. Instead, we use a structure known as a log — an ordered sequence of events, each accompanied by some state and a description of the event.

This structure is intuitive and scalable.

## Topics

Enter Kafka — a robust system designed to manage these logs. In the Kafka ecosystem, these logs are grouped under categories called "topics".

Kafka ensures durability by writing topics across multiple disks or servers, eliminating the risks associated with a single point of failure.

The retention of topics can range from brief periods to years, or even indefinitely, and their sizes can vary from minuscule to massive.

Each event captures a specific business occurrence.

## Thinking in Kafka

Kafka prompts developers to prioritize events over static entities.

Gone are the days when the norm was building a monolithic application with a singular, expansive database.

Now, whether you're working with a single service or multiple ones, they can both consume from and produce to a Kafka topic.

## The Possibilities 

With data residing in these topics, it becomes feasible to establish services that execute real-time analysis by consuming messages directly from topics, as opposed to relying on overnight batch processes.

## Kafka Connect

Kafka offers tools, like Kafka Connect, which facilitates the capturing of database changes as events and populates them into a topic — ready for any use case you envision.

Furthermore, Kafka Connect can export events from a topic into a database or any external system.

## Kafka Streams

While manipulating topics, events can be grouped based on their key, allowing for subsequent aggregation or counting before directing them to another topic.

Kafka simplifies this process through its Kafka Streams API. It's a Java-based API that encompasses all the foundational elements and infrastructure, ensuring scalability and reliability without the developer needing to build these from scratch.

## Outro

Hopefully, this provides an MVP-level foundational understanding of Kafka. Your next step? Dive into the code and experiment firsthand with the Kafka quick start guide.

https://kafka.apache.org/quickstart
How my First Blog went.....
Tags: webdev, beginners, programming, opensource
Published: 2023-09-08 21:45:57

> Hello everyone, myself **Vishnu das Puthukudi**, I am in my last semester of my **Computer Programming and Analysis(CPA)** .I took this course because, I like to work on Open Source projects and study more about what happening around the Open Source Development world. Having to see many project and works by people who are really interested in finding something new was the attraction towards the Open Source environment

- I hope that I can learn more about github and Open Source in this semester and can work with people who have variety of Ideas. I wanna work in projects which are easily access to common people and will be helpful for them in their daily life.

- I took on of the best trending open source codebase which will be known to most of the programmers and developers. Its the **freeCodeCamp**, It is basically an Open Source codebase and curriculum where we can learn to code for free.
[freeCodeCamp](https://github.com/freeCodeCamp/freeCodeCamp)
Event Handling in JavaScript
Tags: javascript, tutorial, webdev, beginners
Published: 2023-09-08 21:41:08

Hey there, JavaScript enthusiast! Ready to add some interactivity to your web page? Well, you're in the right place because today, we're diving into the exciting world of event handling in JavaScript.

## What's an Event?

Before we get into the nitty-gritty, let's talk about what an event is. In the web world, an event is basically something that happens – a click, a keypress, a mouse movement, you name it. These events can be captured and responded to using JavaScript.

## The Event Listener

To catch these events, we use something called an **event listener**. It's like having a spy waiting for specific things to happen on your web page. When that something happens, the event listener jumps into action.

Here's a simple example:

```javascript
const button = document.querySelector('#myButton');

button.addEventListener('click', () => {
  alert('Button clicked!');
});
```
In this code, we're telling JavaScript to listen for a *click* event on the element with the id `myButton`. When the button is clicked, a pop-up alert will appear saying 'Button clicked!'. Magic, right?

## The Event Object

Events can carry extra information with them, like where the mouse was when it was clicked. This additional info comes in an event object.

```javascript
const myElement = document.querySelector('#myElement');

myElement.addEventListener('mousemove', (event) => {
  console.log(`Mouse coordinates: ${event.clientX}, ${event.clientY}`);
});

```
In this snippet, we're logging the mouse's X and Y coordinates whenever the mouse moves over `myElement`. The **event** object contains all the juicy details.

## Removing Event Listeners

Don't forget, you can also remove event listeners if you no longer need them. It's as simple as this:

```javascript
const removeListener = () => {
  button.removeEventListener('click', clickHandler);
};

button.addEventListener('click', clickHandler);
```
## Wrapping Up
And there you have it – a quick tour of event handling in JavaScript! With event listeners and event objects in your toolkit, you can make your web page respond to user actions and create dynamic, interactive experiences.

So go ahead, give it a try! Add some event handling magic to your website and make it come to life.
2023-09-08: Sequence diagrams
Tags: devjournal
Published: 2023-09-08 21:35:16

Another week dedicated more so to planning and prepping rather than explicit coding.

This week, naturally, was a short week of four business days since Monday was Labor Day so I don't have as much to report this week.

Picking up from last week, I continued working on those sequence diagrams. My boss wanted me to fix the formatting for the code that I had on our FigJam board. He also wanted me to start classifying best in class sequence diagrams vs. worst in class. Most of them were decent so my criteria ended up being pretty arbitrary.

I also was tasked with filling out a table of names for each diagram and what possible errors might be thrown, and extracting possible behind-the-scenes functions that are needed. There were quite a few that I came up with, like obviously the Analyzer, the Matcher, the Advisor, and the Feedback. You can probably guess what each of those things do. The goal was to make it so it would extract information from the user in the most naturalistic yet fewest steps possible. My boss had come up with the arbitrary number 6 for number of steps max, which I think is a good number.

After that, we did some pair programming trying to lay out how we'd code such a thing. We came up with a sort of factory system that would build Analyzers, and that's about as far as we got before that session came to its natural end. I think it's an interesting model and it will be great to expand on it further

In other news, I also started to work on a Tetris clone in my free time. It's in the very early stages but I can cover part of what I decided to implement.

First off, I wanted as little outside help with this as possible, since I wanted to flex my programming skills without ChatGPT a bit. However, I did ask it to give me a list of mechanics to implement since I didn't want to wrack my brain trying to think of every little detail about Tetris.

Then I started working from there. I had decided I was going to use Python for this, so naturally I gravitated toward Pygame. I'd used it before in my projects and I enjoy its simplicity. However, this time I decided I'd use PNG files for my assets since I didn't want to deal with drawing every single tile individually through code.

I do still need to actually code out the graphics and all that, but I ended up writing some code for the backend logic of the board and cells via a 2D array, each cell having a color variable and position.

Unfortunately I haven't had *too* much time to work on it. This was about a half a day's work total. I'm working on it sporadically whenever I get bored. There's a reason why I didn't get too committed to the war sim game, and it was because I barely have any time. But we'll work on this piece by piece till it comes along.

But until next time, cheers.
Join Our Webinar: Plug-in Graph Analytics on PostgreSQL with Apache AGE
Tags: postgres, graphdatabase, apacheage
Published: 2023-09-08 21:24:09

## Are you ready to unlock the potential of PostgreSQL and graph technology?

Have you ever wondered how PostgreSQL and Graph technologies might be used to create enterprise data management solutions?

Join Ibrar Ahmed, an accomplished PostgreSQL consultant, and Eya Badal Abdisho, Chair of the Apache AGE PMC, for a webinar on maximizing the open source potential of PostgreSQL and graph technology databases!

In the webinar we will:

* Discover the reasons behind PostgreSQL's rise to the top and why companies are choosing it over other database solutions;


* Explore the benefits of using a graph database as an extension of PostgreSQL and how it can enhance your data management capabilities;


* Learn about the various PostgreSQL extensions available and how to effectively integrate them into your data ecosystem;


* Get practical tips and strategies for seamlessly integrating PostgreSQL and its extensions into your organization's data infrastructure.

Link: https://us06web.zoom.us/webinar/register/WN_PohMAFj0RJuJPAw8bTq1MA#/registration

Date: Sep 14, 2023 - 5:00 PM GMT
.NET Monthly Roundup - August 2023 - .NET 8 Preview 7, Visual Studio releases, perf and GC fun!
Tags: dotnet, visualstudio, aspnet
Published: 2023-09-08 21:22:43

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

Welcome to our August .NET Monthly Roundup with Jon Galloway! In just 3 minutes, Jon breaks down the latest news from the month of August 2023 that .NET developers need to know.

### Top links
📚[All the links](http://aka.ms/dnmr-2308)

⭐.NET 8 Preview 5
➡️[Announcing .NET 8 Preview 7](https://devblogs.microsoft.com/dotnet/announcing-dotnet-8-preview-7/)
➡️[ASP.NET Core updates in .NET 8 Preview 7](https://devblogs.microsoft.com/dotnet/asp-net-core-updates-in-dotnet-8-preview-7/)
➡️[Dynamically Adapting To Application Sizes | by Maoni0 | Aug, 2023 | Medium](https://maoni0.medium.com/dynamically-adapting-to-application-sizes-2d72fcb6f1ea)

💻Visual Studio and Tools
➡️[Visual Studio 2022 – 17.7 Now Available ](https://devblogs.microsoft.com/visualstudio/visual-studio-2022-17-7-now-available/)
➡️[Visual Studio 2022 17.8 Preview 1 has arrived! ](https://devblogs.microsoft.com/visualstudio/visual-studio-2022-17-8-preview-1-has-arrived/)
➡️[Safely use secrets in HTTP requests in Visual Studio 2022 ](https://devblogs.microsoft.com/visualstudio/safely-use-secrets-in-http-requests-in-visual-studio-2022/)
➡️[Visual Studio for Mac Retirement Announcement ](https://devblogs.microsoft.com/visualstudio/visual-studio-for-mac-retirement-announcement/)
➡️[Announcing the Unity extension for Visual Studio Code ](https://devblogs.microsoft.com/visualstudio/announcing-the-unity-extension-for-visual-studio-code/)

❤️Community Links and Events
➡️[.NET 8 Interceptors | Khalid Abuhakmeh](https://khalidabuhakmeh.com/dotnet-8-interceptors)
➡️[Tales from the .NET Migration Trenches - Intro](https://www.jimmybogard.com/tales-from-the-net-migration-trenches/)
➡️[Keyed service dependency injection container support](https://andrewlock.net/exploring-the-dotnet-8-preview-keyed-services-dependency-injection-support/)
➡️[.NET Conf 2023 - Celebrating the Release of .NET 8! - Save the Date!](https://devblogs.microsoft.com/dotnet/dotnet-conf-2023-celebrating-the-release-of-dotnet-8-save-the-date/)
➡️[.NET Conf 2023](https://www.dotnetconf.net/)

### What did you think?

With so much new information coming at you each month, we're looking at ways to bring you the highlights. Let us know if this helps, and how we can do it better next month!

Jon
Understanding Indexes in Postgresql
Tags: postgres, apacheage
Published: 2023-09-08 21:22:31

## What is an index?
An index is a structure utilized for quick data retrieval operations. In the database world, an index is associated with a table and used to efficiently locate data without having to investigate every row in a database table. If a table does not have an index, then a full table scan is needed to find a record, which is very costly in terms of disk I/O and CPU utilization. 
A full table scan is the process of sequentially reading every record from disk, checking against search criteria, and building a result set.

It is good to note that an index amends the performance of database operations at the cost of extra replicas of data. As an index stores the extra copy of data for more speedy access, an index is the routine way to amend the performance of the database. 
In a nutshell, an index is a quick access path to a single row of a table in the database. A database index is similar to a book index where any specific information can be located by looking at the index page to avoid the full search of the book, which is an exhaustive operation. Similarly, a database index is created to minimize table traversal and maximize performance.
An index can be created utilizing a single column or multiple columns of a table. Once the index is created, then there is no further intervention needed; the index will be automatically updated on each DML operation on the table. After creating the index, it is the planner’s decision to utilize the index in lieu of sequential scans based on cost.

### How to create an index
The CREATE INDEX command is used to create an index the basic syntax of creating an index on a table is as follows:
```
CREATE INDEX index_name ON table_name (column_name);
```
Here is an example of creating an index on the item_id column of the item table:
```
warehouse_db=# CREATE INDEX item_idx ON item (item_id);
```
The result can be seen using the following statement:
```
warehouse_db=# \di item_idx;
               List of relations
 Schema |   Name   | Type  | Owner    | Table
--------+----------+-------+----------+-------
 public | item_idx | index | postgres | item
(1 row)
```
The index name is optional; if the index name is not specified, PostgreSQL generates the index name using the table name and the column name. In the preceding example, we have specified the index name. In the following example, PostgreSQL generates the index name using the table name and column name, which is item_item_id_idx:
```
warehouse_db=# CREATE INDEX ON item (item_id);
```
### CREATE INDEX
The result can be seen using the following statement:
```
warehouse_db=# \di item_item_id_idx;
                 List of relations
 Schema |       Name       | Type  | Owner    | Table
--------+------------------+-------+----------+-------
 public | item_item_id_idx | index | postgres | item
(1 row)
```
Creating an index on a large table can take a long time; for example, in the preceding example, the query has to scan all the records and generate the index data. On a larger table, this process can take time.
Git Branch Strategy vs. Git Workflow
Tags: git, github, versioning
Published: 2023-09-08 21:16:23

Let's get started,

## Git Branch Strategy
A Git branch strategy, also known as a branching model, is a set of rules and conventions that dictate how branches are organized, created, named, and managed within a Git repository.

**Purpose**: It defines the structure of branches and their relationships, helping teams manage code development and integration efficiently. The branch strategy provides guidelines on when to create feature branches, how to handle long-lived branches, and how to handle releases and hotfixes.

**Examples**: Feature branching, Gitflow, GitHub Flow, GitLab Flow, Trunk-Based Development, and others are examples of Git branch strategies.

**Focus**: Git branch strategies primarily focus on the branching and merging aspects of version control, including the creation of feature branches, release branches, and maintenance branches.

## Git Workflow
A Git workflow is a set of defined processes and conventions that a development team follows when using Git for collaborating on and managing code changes. It outlines how developers interact with the version control system throughout the development lifecycle.

**Purpose**: It addresses not only branching and merging but also the broader development and collaboration practices, including how features are developed, reviewed, tested, and integrated into the codebase.

**Examples**: Pull Request (PR) Workflow, Feature-Driven Development (FDD), GitOps Workflow, Continuous Integration/Continuous Deployment (CI/CD) Workflow, and others are examples of Git workflows.

**Focus**: Git workflows encompass the entire software development lifecycle, including code review processes, issue tracking, testing, and deployment. They may incorporate a specific Git branch strategy as part of the overall process.


## Wrap-Up!
_Git Branch Strategy is a subset of a Git Workflow._
* The branch strategy defines how branches are structured and managed, while the Git workflow outlines the broader set of practices and procedures for collaborating on code using Git. 

A workflow can incorporate or be tailored to a specific branch strategy, but it also addresses other aspects of software development beyond just branching and merging. The choice of a Git branch strategy and Git workflow depends on the project's requirements, team size, and development practices.

Happy Coding!
Jual Obat Aborsi
Tags: obataborsi, cytotec
Published: 2023-09-08 20:52:13

Jual Obat Aborsi Asli Wa 08222-5555-180

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/b87tboyszsrbdux0c0gd.jpg)
How to add quotes, brackets, parenthesis, and more to a visual mode selection in vim
Tags: vim, neovim, brackets, quotes
Published: 2023-09-08 19:57:11

# vim-autoSurround

## Resume
Hi every body, today I publish my plugin for vim and neovim, for add pairs of: “ ”, ' ', < >, ( ), { } or/and [ ] to a visual mode selection in vim, like vscode does.

## Install
You can add this plugin to your vim cloning my repo:
[https://github.com/dapt4/vim-autoSurround](https://github.com/dapt4/vim-autoSurround
)
Or using a Plugin manager like:

"NeoBundle
`NeoBundle 'dapt4/vim-autoSurround'`
"or VimPlug
`Plug 'dapt4/vim-autoSurround'`

:source %
:NeoBundleInstall
"or
:source %
:PlugInstall


## Usage
Just select the text with visual mode “v” and type one or all of these: ", ', `, <, >, (, ), { and/or }.
I just enabled TS support in the framework I am working on, should I stop?
Tags: node, typescript, javascript, framework
Published: 2023-09-08 19:49:45

hi,

I am working on an open-source NodeJs Framework, 

[https://github.com/3rd-planet/framework-x](https://github.com/3rd-planet/framework-x)

I just enabled the TS support for it and planned to create every feature in both JS and TS. But, now there is an ongoing debate over the dropping of TS by some big giants. What should I do? Ignore the debate and keep on going or I should drop TS too?

Your suggestion will be appreciated.