teleren/devto huggingface dataset:
IR - Incident Response, Repair, Resolution or Remediation?
Tags: sre, devops, cloudnative, cloudskills
Published: 2021-11-03 21:26:48

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

##What does IR stand for?

Many people consider it to be Incident Response. In this case an incident refers to something not operating correctly in a cloud environment. The issue could be small - say a performance impact that doesn’t really affect successful operations. Alternatively, the impact could be massive - an outage that has ceased all operations with data loss, revenue loss, and damaged reputation (consider the recent [Facebook outage](https://www.fylamynt.com/post/global-outage-at-facebook-whatsapp-and-instagram) or [Roblox outage](https://blog.roblox.com/2021/10/update-recent-service-outage/)).

##Incident Response

When an incident occurs, organizations will typically be alerted from a monitoring tool. These tools have parameters and ranges of acceptable use (think too many 500s, or too long to respond). The tool will likely then trigger an alert, which could come from another tool. The alerting tool could be simple (page everyone) or there could be sophisticated rules to page just the on-call team, or the subject matter experts for the type of incident. Next comes the much harder part, fixing the problem.

##Incident Repair, Incident Resolution, Incident Remediation

These three terms all refer to the same basic result: the incident is fixed and operations are back to normal. Depending on the incident, the difficulty to resolve could be very simple, or take hours or days. The amount of time to repair the incident is called MTTR. Obviously, you want your MTTR to be as low as possible, and you want to consider more advanced tools and methodologies to achieve that. Reducing MTTR is one of the key objectives of a site reliability engineer (SRE). 

##How are incidents resolved?

Savvy organizations start by creating [runbooks](https://www.fylamynt.com/post/whats-a-runbook). These runbooks are basically an instruction manual on what to do, in what order, to remediate the incident. Simple incidents could be handled by level 1 support personnel, while multi day outages will be all hands on deck. 

Runbooks can have many steps in them, but a typical set of high level steps are as follows:
* Type of incident, what services are affected
* How to collect the data and logs to verify the incident
* What to do to correct the incident (this could be pages)

At Fylamynt, we call runbooks a workflow. Fylamynt has built the world’s first enterprise ready low code platform for building, running and analyzing SRE cloud workflows. With Fylamynt an [SRE can automate](https://www.fylamynt.com/post/can-i-automate-away-sre-roles) the parts of the runbook that are the most time consuming, allowing them to make decisions where their expertise is needed, removing mistakes and simple errors.

[Try Fylamynt for free ->](https://fylamynt.com/)
Database Management Systems 1
Tags: database, sql, beginners, webdev
Published: 2021-11-04 01:44:08

#### TL;DR
Lets take a look at the ecosystem for databases and the tools that govern them.

To note, a database is a collection of inter-related data which helps in efficient retrieval, insertion and deletion of data from database and organizes the data in the form of tables, views, schemas, reports and more.

Looking at what database management systems can do we realize that these tools are used to manage our databases out of the box. 

In short, a database management system is the software used to efficiently and reliably handle data processing and management. 

## Introduction

##### By the end of this tutorial, you will
- Understand the fundamentals of databases
- Working points of DBMS
- How to run simple Database queries

### Core Concepts
> We must always be thinking about our data

##### Quick use cases,
1. Creation of a database
2. Retrieval of information from the database
3. Updating the database
4. Managing a database

With DBMS's being so important in the management of our databases a DBMS will look to focus on the following problems: Redundancy of data, Inconsistency of Data, Difficult Data Access, Unauthorized Access, No Concurrent Access, No Backup and Recovery.

##### Architecture 
The structure of a DBMS is laid out in three levels which are known as your physical, conceptual and external levels. This can be looked at as a 3-tier'd architecture in relation to what a DBMS provides. 

Each level will serve a specific focus for a DBMS as the physical layer is the information about the location of database objects in the data store is kept. The conceptual level data is represented in the form of various database tables. At the external level objects will specify a view of the data in terms of conceptual level tables.

As noted earlier, we must always think about our data. This is important walking through the 3-tier architecture as data independence states that changes in data at one level shouldn't affect another. 

Types of Data Independence: 

1. Physical Data Independence: Any change in the physical location of tables and indexes should not affect the conceptual level or external view of data.

2. Conceptual Data Independence: The data at conceptual level schema and external level schema must be independent.

*This concludes the first part of my series on Database Management Systems, I will be posting more on whats to be continued shortly!*
Easily validate tsconfig.json, Use the 'tsconf-checker' package
Tags: typescript
Published: 2021-11-04 01:42:51

## Introduce
Wouldn't it be convenient if you could easily check the settings of `tsconfig.json` you are using? 
Introducing [tsconf-checker](https://github.com/activeguild/tsconf-checker), a package that can solve such problems.

## Usage
```json
{
    "compilerOptions": {
        "target": "esnext",
        "module": "commonjs",
        "baseUrl": "./src",
        "resolveJsonModule": true,
        "outDir": "./dist",
        "esModuleInterop": true,
        "forceConsistentCasingInFileNames": true,
        "strict": true,
        "strictFunctionTypes": true,
        "skipLibCheck": true
    }
}
```

Specify the typescript file that targets `tsconfig.json` you want to check and execute the following command.
```bash
npx tsconf-checker index.ts
```

The result of the check is displayed.
```bash
Warning: 'strictFunctionTypes' is implicitly true because 'strict' option is true.
Warning: 'skipLibCheck' option is officially recommended to be false.
Warning: 'esModuleInterop' option is officially recommended to be false.
Warning: 'forceConsistentCasingInFileNames' option is officially recommended to be false.
```

This function is perfect for you who want to have fun.
100 Días de código: 2, primeros pasos con Jest #100DaysOfCode
Tags: spanish, webdev, 100daysofcode, testing
Published: 2021-11-04 01:13:15

👋 ¡Bienvenido! 

Este es mi segundo día en el reto #100DaysOfCode y hoy he decidido dedicarme a comenzar con el aprendizaje del testing en Javascript, no se porque siempre lo omití.
Al investigar me encontré con un framework bastante conocido que tiene una guía para aprender a hacer testing y es...
🎉Jest🎉

En su documentación la cual puedes encontrar [aqui](https://jestjs.io/docs/getting-started) se puede dar los primeros pasos de como comenzar a hacer testeo de Javascript

Con ayuda de ello cree unos cuantos repositorios que me permitieron hacer unas cuantas pruebas y llenar un poco el vacío que hay en mi github.

Ahora quiero añadir un extra a estos blogs en donde explique que cosas realice y aprendí como una nueva sección que seria similar a lo que se haría en un scrum.
### Ayer 
1 Pensé y prepare los contenidos que quería aprender en este reto. 
2 Planee los cambios que quiero hacer a mi pagina web. 
3 Cree un ejemplo de una API CRUD con Node y Express. 
4 Aplique Pomodoro a mis tiempos de código y estudio.

### Hoy
1 Diseñe los wireframes de las secciones principales de mi pagina web.
2 Comencé a practicar testing con Jest.
3 Aprendí test asíncrono y síncrono con Jest.
4 Aprendí a agrupar test con la función de Jest `describe`
5 Aprendí que los métodos de Jest `beforeEach()` y `afterEach()` se ejecutan antes y despues de cada test respectivamente y que los métodos como `beforeAll()` y `afterAll()` te permiten ejecutar código antes y despues de todos los testeos, respectivamente.
![lista de cosas](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/51f18ofhe5mwl22kxzbf.jpg)
Y bueno eso es todo por hoy, recuerden que esto **no es un tutorial** si no solo mis propias experiencias en mi día a día.

Que tengan una bonita noche y éxito con todo lo que deseen y tengan que hacer.🎉
Thabet GG kênh nhà Cái uy tín số 1 Việt Nam
Published: 2021-11-04 00:31:31

THABET GG✔️✔️✔️ Nhà cái Tha Casino uy tín số 1 VN ✍️ Đăng ký THA BET nhận khuyến mãi tiền cược 388k Trang chủ chính thức tải app 
 Địa Chỉ : Hồ Chí Minh    
Social : 
https://www.pinterest.com/thabetggonline/_saved/
https://www.twitch.tv/thabetggonline
https://thabetggonline.tumblr.com/
https://gab.com/thabetggonline
https://www.ted.com/profiles/30965294
https://thabetggonline.netboard.me/
"Agile" is not a noun
Tags: agile, softwaredevelopment
Published: 2021-11-16 09:01:23

---
title: "Agile" is not a noun
published: true
date: 2021-11-04 00:00:00 UTC
tags: agile,softwaredevelopment
canonical_url: https://jhall.io/archive/2021/11/04/agile-is-not-a-noun/
---

I’ve seen a _lot_ of time spent, and (virtual) ink spilled over the question of “What is the definition of _Agile_?”

“Agile is a project management approach…”

“Agile is a philosophy…”

“…set of practices…”

“…a mindset…”

No matter how general or specific the definition you come up with, someone has an objection, and endless bikeshedding ensues.

What if there were an easier way to think about this?

Going all the way back to the manifesto which kicked things off, the word “agile” is actually used as an adjective, not a noun. Remember, the proper name for the famous document is _not_ “The Agile Manifesto”, as we often call it, it is “The Manifesto for Agile Software Development.” That is to say: It’s a manifesto about software development, with “agile” as an adjective describing the way software development is done. “Agile” is not the thing (the noun) about which the manifesto is written.

Merriam-Webster [defines _agile_](https://www.merriam-webster.com/dictionary/agile) as:

> **agile** _adjective_
> 
> able to move quickly and easily

With this definition in mind, I think it’s much easier to come up with a definition of _agile_ software development that requires a lot less hair-splitting. And I think this is clearly in line with the [principles of the manifesto](https://agilemanifesto.org/principles.html).

Are we developing software and related systems in a way that can move quickly and easily? If so, we’re accomplishing agility. If not, well…

* * *
_If you enjoyed this message, [subscribe](https://jhall.io/daily) to <u>The Daily Commit</u> to get future messages to your inbox._
JavaScript: How To Return Data From A Function In Sqlite3
Tags: programming
Published: 2021-12-31 08:59:36

---
title: JavaScript: How To Return Data From A Function In Sqlite3
published: true
date: 2021-11-04 00:00:00 UTC
tags: Programming
canonical_url: https://www.Kudadam.com/blog/return-data-from-sqlite3-nodejs
---

<nav><p>Table Of Contents</p>
<ol>
<li>
<a href="#the-problem">The Problem</a><ol><li><a href="#why-undefined">Why Undefined?</a></li></ol>
</li>
<li>
<a href="#the-solution">The Solution</a><ol>
<li><a href="#modified-code">Modified Code</a></li>
<li><a href="#explanation">Explanation</a></li>
</ol>
</li>
</ol></nav>

Whiles trying to implement a read counter for my website this morning, I run into a bug. The function which returned the query from the database always returned _undefined_

## The Problem

```javascript
const getData = (slug)=>{
    let data;
    db.serialize(()=>{
        db.get('SELECT * FROM blog WHERE slug = ?',slug, (err, rows)=>{
            data = rows;
        })
    });
    return data;
}

let data = getData("return-data-from-sqlite3-nodejs") // => undefined
```

This was my code snippet, the function `getData` takes a slug as parameter, then it searches the database to retrieve all the data for the slug. It then assigns the data to the `data` variable, then at the end of the function, it returns the `data` variable. The function without a doubt works perfectly but when you run it, it will always return undefined.

### Why Undefined?

The reason why the function returns undefined is that, `db.get` is an asynchronous function, so the return statement will always run before the function has even completed it’s work.

## The Solution

Since the `db.get` function is asynchronous, we need to find a way to make it return it’s value once it has finished it’s work and the solution is by using [Promises](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise). So we need to wrap the whole code in a Promise and when the function finishes executing, the promise will return the results.

### Modified Code

```javascript
const getData = (slug)=>{
    return new Promise((resolve, reject)=>{
    db.serialize(()=>{
        db.get('SELECT * FROM blog WHERE slug = ?',slug, (err, rows)=>{
            if (err)
                reject(err)
            resolve(rows)
        })
    });
    })
}

let promise = getData("return-data-from-sqlite3-nodejs") // => Promise { <pending> }
.then(results=>{
console.log(results) // => { slug: 'adding-matomo-website', read_times: 1, shares: 0, likes: 0 }
})
```

### Explanation

So basically, what we did was wrap the whole function in a Promise and pass the `rows` to `resolve` if our code run successfully, else we pass the `err` to `reject` if there were any errors.

Oh, by the way, you can get the json of how many times this blog post has been read from this url [/blog/return-data-from-sqlite3-nodejs.json](/blog/return-data-from-sqlite3-nodejs.json)
How-To: Java isDigit() function
Tags: java, codenewbie, tutorial, 100daysofcode
Published: 2021-11-03 23:48:52

---
title: How-To: Java isDigit() function
published: true
description: How-To: Java isDigit() function
tags: Java, codenewbie, tutorial, 100daysofcode
//cover_image: https://direct_url_to_image.jpg
---

Sometimes it is helpful to know if a character is a digit (`0`-`9`) or not.

The built-in Java Character class provides an `isDigit()` function that determines if a character is a digit or not. If it is, the function returns `true`. Otherwise, it returns `false`.

Here is an example. Declare and populate some character values to test:

```java
char c1 = '9';
char c2 = 'A';
```

The `c1` variable contains a character value that is a digit. The `c2` variable contains a character value that is not a digit.

To invoke the `isDigit()` function, use the `Character` class and pass in the character to test as the parameter. The return value of the function is a `Boolean` (`true` or `false`) value.

This statement checks if the `c1` variable contains a digit and stores the result in a Boolean variable `b1`:

```java
boolean b1 = Character.isDigit(c1);
```

Since the character `'9'` is a digit, the statement assigns `true` to `b1`.

The same process checks the `c2` variable:

```java
b1 = Character.isDigit(c2);
```

This time, the program assigns `false` to `b1`, because `'A'` is not a digit.

Here is the complete program:

```java
public class Example {
  public static void main(String[] args) throws Exception {
    
    char c1 = '9';
    char c2 = 'A';

    boolean b1 = Character.isDigit(c1);
    System.out.println(b1); // true

    b1 = Character.isDigit(c2);
    System.out.println(b1); // false
  }
}
```

The `Character.isDigit()` function is very useful when determining if a character is a digit or not. This can help with a variety of string processing tasks in the programs you write.

Thanks for reading. 😃

*Follow me on Twitter [`@realEdwinTorres`](https://twitter.com/realEdwinTorres) for more programming tips and help.*
A Developer's Willpower
Tags: beginners, webdev, programming
Published: 2021-11-03 23:13:29

One thing about me is that I love comic books. I’ve been collecting comic books since I was able to read. Since this is “New Comic Book Wednesday”, I started to think about what heroes would be amazing software developers. At first, I have the usual suspects: the heroes that have high IQ. We have characters like Tony Stark, Bruce Wayne, Peter Parker, etc. that technical acumen that they would excel as software developers. I see a lot of lists of traits for the ideal software developer. I’m listing some of those prevalent traits problem solving, passion, creativity, quick learner, honesty, patience, communication skills, open-minded, overly helpful, attention to detail, stress handling, laziness, flexibility, well organized, open for criticism, likes to create, handling failures, embrace trends, a technical mindset, business perspective, self-confidence, and love with technology.  I never saw willpower in those lists. If a developer has willpower you can easily handle stress, failures, and setbacks. The hero that has a lot of willpower is Hal Jordan the Green Lantern. I think Hal would be an excellent developer. He could even have his own developer oath "In brightest day, in blackest night, No bug shall escape my sight. Let those who worship evil bugs might. Beware my power--GitHub’s green light!" On your journey don’t forget to develop grit and willpower that help you get through those tough times. For without willpower, I won’t be the developer today.

Until the next time #KeepBringingThatFullStackEnergy

BK
How to install GA in React (Easiest way in 2021)
Published: 2021-11-03 22:33:29

## Introduction

I'm very excited to be writing this article, such as it is coming from one of my favorite topics, which apart from being React, is Search Engine Optimization.

Google Analytics is the key step for any SEO process.

It is used to track conversions, look at demographics, and events.

It also helps keep track of how your traffic is behaving.

The idea behind GA is to have a solid understanding of not only knowing how many visitors do you have, but also why they are on your website, and what are they doing there.

Having said that I'm going to show you the EASIEST way, for you to install GA in a React app and start tracking visitors accordingly.

A little caution with this method is that you may not want to use this for the long run or use it for big web apps.

Ideally, this article is for those who **just want to have GA in their React app**, and don't want to spend more than 5 minutes in the process.

## How to install Google Analytics in React.js (Easiest way)

**First step:** Get your Global site tag (gtag.js)

Go to your Google Analytics account

And search for _Data Streams,_ and click on it

[![Screen capture of Data Streams](https://i.postimg.cc/s2t4xPv2/Captura.png)](https://postimg.cc/NykHPH8h)

Click on your data stream

[![Image of data stream](https://i.postimg.cc/wBv9MJnn/Captura.png)](https://postimg.cc/75pFQCHN)
A copy your `gtag.js`

[![Gtag screen capture in GA](https://i.postimg.cc/mgQGrjdd/Captura.png)](https://postimg.cc/jDd1gHYN)

**Second step**: Paste the `g.tag.js` inside `index.html` (located in the public folder)

Do you know the public folder when you do `npx create-react-app`?

Well, what we are going to do is to paste the exact script that Google Analytics gives us, and paste it in our index.html inside our public folder.

[![Folder structure screenshot](https://i.postimg.cc/cLsM248F/Captura.png)](https://postimg.cc/dLxyTF6C)
Inside `index.html` we are going to paste the exact `g.tag` code at that GA gave to us:

```js
<html>
<body>
   ...
 </body>
<script async src="https://www.googletagmanager.com/gtag/js?id=G-****"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());

  gtag('config', 'GA-CODE');
</script>
</html>
```

So in some sense, we are not going to be working with JSX, and you can even say without React.

## The issue with this method

This technique will allow you to install GA in a really simple and bugless manner.

It is dead simple, and for **landing pages made with React**, I think it works great.

But for a blog like this one or even a full web app you might need to go the `react-ga` route.

# Read more articles like this one on:
reactshark.com
Essentials of README
Tags: beginners, programming, documentation
Published: 2021-11-03 22:23:35

`README.md` is a minimum qualifying requirement to call a project well documented. It is basically an introduction to your project. 

A `README` file typically written in [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Here-Cheatsheet) and contains: 

## :clipboard: Summary 
A short description of the problem the project solves. 

## :star2: Key Features 
A list of features that make your project great at solving the given problem. 

## :arrow_forward: Getting Started 
This section is basically a usage guide. Include installation and usage instructions here. 

This is also a good place to add some code examples as well.

## :computer: Contribution Notes 
Discuss coding style and guidelines. Include steps to run test suite and introduce the contributor to any CI validation (if already setup)

## :exclamation: Support 
List ways in which your end users can seek help. Email, Slack and JIRA are some good ways of allowing your users and developers to file bugs and ask for help. 

> :bulb: Focus on building a community of expert users and developers, so that you don't have to support your project all the time.  

## :copyright: License 
Read about licenses [here](https://choosealicense.com). 


---

I found a collection of [awesome-readmes](https://github.com/matiassingers/awesome-readme) which you might enjoy as well!