teleren/devto huggingface dataset:
Take the blue pill, the story ends
Tags: agile
Published: 2022-08-13 11:39:53

---
title: Take the blue pill, the story ends
published: true
date: 2022-02-21 00:00:00 UTC
tags: agile
canonical_url: https://jhall.io/archive/2022/02/21/take-the-blue-pill-the-story-ends/
---

In the [Allegory of the Cave](https://en.wikipedia.org/wiki/Allegory_of_the_cave), Socrates describes a people living in chains, facing a blank cave wall upon which shadows are cast by unseen objects or people passing between a fire and the wall. Those living in chains only see the shadows, a poor representation of the greater reality, but the only experience of reality they’ve ever seen or known.

If someone escapes the chains, and is able to turn around and see the fire that is the source of light, and the objects or people passing between the fire and the cave wall, their attempts to explain this reality to their still-enslaved colleagues will be fraught with frustration.

To me it seems we often have the same problem when it comes to discussing software development, and particularly when we talk about “Agile”.

One attempt to bridge this gap between “reality” and the “cave wall” is talk of “big A Agile” versus “small A agile”, which I interpret as follows:

“Big A” Agile typically refers to “the Agile Industrial Complex.” That is, “Agile as sold to large companies.” This version is largely focused on frameworks, certifications, check-boxes, to-do lists, maturity indexes. It loves to _quantify_ agility. This is the 2-dimensional version of reality, cast upon the wall as shadows that everyone thinks they understand.

“Little a” agile, in contrast, is meant to convey the principles in the [Manifesto for Agile Software Development](https://agilemanifesto.org/). It’s much fuzzier, more subjective, harder to define, and therefore harder to “sell.” This is an attempt to explain the larger reality, often to those still chained, looking only at the cave wall.

But this won’t help anyone. According to the allegory, anyone living in chains will be incapable of understanding what the unchained are talking about.

Is there hope?

Maybe there is.

The best I can tell, whether one lives in “agile chains” or not, comes down to how one responds to a single question. The question may sound subtle, but the implications are anything but. It’s a red pill/blue pill kind of question.

![](https://jhall.io/images/red-pill-blue-pill_hub55aa323f77526fb6ef4d424acc13f92_61821_400x0_resize_q85_box.jpg)

> You take the blue pill, the story ends, you wake up in your bed and believe whatever you want to believe. You take the red pill, you stay in wonderland, and I show you how deep the rabbit hole goes.  
> — Morpheus, _The Matrix_

I’ll expand on my thoughts on this question and its implications soon. For now, I’ll leave you to ponder it.

So what’s the question?

_ **How do you respond to uncertainty?** _

* * *
_If you enjoyed this message, [subscribe](https://jhall.io/daily) to <u>The Daily Commit</u> to get future messages to your inbox._
BandarQ DominoQQ
Tags: kasqq, bandarq, dominoqq, pkvgames
Published: 2022-02-20 23:39:45

## KASQQ SITUS JUDI BANDAR Q | DOMINO QQ PKVGAMES TERPERCAYA DEPOSIT PULSA TANPA POTONGAN
-BONUS ROLLINGAN TERBESAR 0,3% - 0,5%
-BONUS REFFERAL 20%
Daftar sekarang > https://omli.club/kasqqpkvgames
Contact Person Kami:
--WA : +6282122134507
Link WA : https://wa.me/6282122134507
-Telegram: kasqqpkvgames
Link Telegram: https://t.me/kasqqpkvgames
SITUS RESMI: QQKAS,org (koma ganti titik)
Git Basic Commands
Tags: beginners, git, tutorial, productivity
Published: 2022-02-20 23:07:19

#About this article

In this article, I will share with you guys what are the basic commands when using git CLI.

> I know who did what, when, and why. -Git
>

## Table of Contents
1. [Git: configurations](#git-configurations)
2. [Git: starting a repository](#git-starting-a-repository)
3. [Git: staging files](#git-staging-files)
4. [Git: committing to a repository](#git-committing-to-a-repository)
5. [Git: pulling and pushing from and to repositories](#git-pulling-and-pushing-from-and-to-repositories)
6. [Git: branching](#git-branching)

##Git: configurations

```bash
git config <followed with>
```

followed with: 

```bash
--global user.name "FirstName LastName"
--global user.name "yourEmail@email.com"
--global color.ui true
--list
```

##Git: starting a repository

```bash
git init
git status
```

##Git: staging files

adding files to staging area

```bash
git add <fileName>
git add <fileName> <anotherFileName>
git add .
git add --all
git add -A
```

removes a file from the staging area

```bash
git rm --cached <fileName>
```

discard change or reset the file

```bash
git reset <fileName>
```

##Git: committing to a repository

Appendix: 

-m → stands for a message

```bash
git commit -m "Add three files"

```

undo the last Git commit

```bash
git reset --soft HEAD^
```

##Git: pulling and pushing from and to repositories

Appendix:

-u → add upstream (tracking) reference

```bash
git remote add origin <link> //Adding a remote repository
git push -u origin master //pushes all your branches to the origin.
git clone <cloneURL> // clone a repository
git pull // download all the changes 
```

##Git: branching

```bash
git branch // current branch
git branch <branchName> // create a branch
git checkout <branchName> // change current branch
git merge <branchName> // merge branchName to current branch
git checkout -b <branchName> // create and checkout a new branch
```

If you guys have other thoughts leave a comment I'll update the post base on your solutions as well.. cheers🍻
Introduction to Data Structures and Algorithms With Python.
Tags: python, beginners, programming, tutorial
Published: 2022-02-20 22:54:24

## **Why Data Structures and Algorithms Are Important?**
Data structures and algorithms provide a set of unique techniques for effectively managing data. A programmer should understand the basic concepts of data management .That is, to collect data a programmer needs to access and manage data effectively using data structures and algorithms .To write efficient code that handles data one needs to understand algorithms and data structure. It would take longer to resolve a problem if the programmer does not know the predefined algorithm techniques.
**

## What are data structures?
**
A data structure is  a format used to store and organize data. They are fundamental to all programming and most programming languages come with them built in.
<u>Types  of data structures</u>
**Lists**
Lists can also be defined as arrays .They are ordered collections of data. To create a list we:

```
List = [1, 2, 3, "GFG", 2.3]
print(List)

```
**Tuples**
A tuple is a list that cannot be modified but can have various types of data
**Sets**
Sets are  used to include membership testing and eliminating duplicate entries
**Stacks**
A stack is like a list the only difference is you can add and remove the last item .If you have the list [1, 2, 3], you can delete the items it contains by first removing 3 then the rest. Removing an item from a stack is called popping.
To add items to the stack we use:

```
stack = Stack()
stack.push(1)
print(stack.is_empty()
```
)
**Queues**
A queue is  like a stack because you can only add and remove items in a certain order; the first item added is the first item removed
To add items on a queue we:

```
a_queue = Queue()

for i in range(5):
    a_queue.enqueue(i)
```
**Linked List**
A linked list is where the elements are not stored at contiguous memory locations. A linked list is represented by a pointer to the first node of the linked list. The first node is called the head. If the linked list is empty, then the value of the head is NULL.
**Dictionaries**
A dictionary is a collection which is ordered*, changeable and do not allow duplicates. Dictionaries are used to store data values in key: value pairs. Dictionaries are written with curly brackets, and have keys and values:

```
thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)
```
An _algorithm_ is a series of steps that can be taken to solve a problem.
To learn more about data structures and algorithms and the best way to use them here is a YouTube [videohttps://www.youtube.com/watch?v=pkYVOmU3MgA](url)
Introduction to Data Structures and Algorithms With Modern JavaScript. 
Published: 2022-02-20 22:27:46

JavaScript being the language of the most popular language of the web has includes arrays, queue, stack and linked list. This is what we will be talking about.
Starting with arrays they are special variables, which can hold more than one value. 
i.e const cars = ["Mercedes", "VW", "RangeRover"];

An array can hold many values under a single name, and you can access the values by referring to an index number. i.e
const cars = [];
cars[0]= "Mercedes";
cars[1]= "VW";
cars[2]= "RangeRover";
Boas práticas em classname no CSS
Tags: css, react, sass, typescript
Published: 2022-02-20 22:22:58

## Introdução

Creio que todo desenvolvedor seja back-end ou front-end tem aquele "receio" de mexer com o CSS. Faz uma estilização em uma parte específica da aplicação e os estilos adicionados acabam "vazando" para outros elementos. As classnames em CSS são altamente utilizadas para poder separar a estilização e também utilizada como seletor e muita das vezes não tomamos o cuidado necessário ao escolher nomes semâticos para nossas classes, que consequentemente podem ocorrer esse "vazamento" de estilos.

## O modelo BEM

Este modelo BEM, vejo como sendo bem importante na separação de pequenas partes da aplicação em componentes. Sendo assim, quando pensamos em componentes, temos aquela ideia de algo que faz parte de um contexto específico e que pode ser dinâmico. Nesse modelo a letra B significa "Block", a letra E significa "Element" e por último temos a letra M que significa "Modifiers". Para ficar mais claro, vamos partir para o código e ver como isso se aplica na prática.

## Aplicação demo

A aplicação que será utilizada contém apenas um textfield para simplificar. As tecnologias utilizadas são: React, Typescript e node-sass. Temos um simples componente de TextField. Analisando este componente, podemos perceber que ele já é um bloco, ou seja...

Link do post original: https://andersonnsilva.site/post/boas-praticas-na-nomeacao-de-classname-no-css
Blockchain Developer salaries in 2022
Published: 2022-02-20 22:06:31

I don't care what your opinion is about crypto nfts Web 3 or blockchain technology, i can tell you that blockchain developers are paid on ziprecruiter.com.
 You can see that the national average for blockchain developers is 155k and that the top 30 percentile earns well over 180 grand. Trust me when i say that i have heard of blockchain developers making a lot more than the website shows.
Nagios Plugins for Linux v30
Tags: c, nagios
Published: 2022-02-20 21:18:44

This open-source project "Nagios Plugins for Linux" provides several binary plugins for monitoring (physical and virtual) Linux hosts with [Nagios](http://www.nagios.org/) and Nagios-compatible monitoring systems like [Icinga](https://icinga.com/learn/) and [Naemon](https://www.naemon.org/).

**What's new in this release**

**FIXES**

Plugin `check_pressure`

- Display values per second regardless of the delay, and ensure the delta of "some" is calculated correctly.
- Thanks to [Christian Bryn (epleterte)](https://github.com/epleterte) for reporting and fixing a typo in the git clone command.

Package creation

- Fix Debian packages creation.

**ENHANCEMENTS / CHANGES**

Libraries

- `lib/netinfo`: fix a LGTM static analyzer alert.

Packages

Release updates:

- Add Debian 11 and drop Debian 8,
- Add Fedora 35 and drop Fedora 32,
- Add Linux Alpine 3.15 and drop version 3.12.
I created a basic node module and it does the job!!
Tags: json, node, javascript
Published: 2022-02-20 20:47:52

First of all, I have created another node module 5 years ago, so this is not my first time. I published it because I can. This one isn't that different... but, let me tell the story.

```
Package name: 'jsonian'
version: '0.0.2' 
// I had to correct the readme, otherwise it is same as 0.0.1
```

## So what does it do?

It lets you persist javascript object to a json file.


...Am I getting Eyeballs yet? 

Yeah, there are bunch of other modules that let you do it. I didn't like the way they expose the api. Most ones I found use a getter/setter approach. 
Nothing wrong with that, may be it is even better for certain application.

I am working on a jupyter notebook and I wanted a way to keep my js objects and json files to be in sync without changing the syntax too much.

I'll share a bit of `Readme.md` here

## Usage

```js
const jsonian = require('jsonian');

const $table = jsonian('./testTable.json'); // file must already exist
```
`$table` is proxy to a root object. You can use it to get or set values as with a usual object.

```json
// './testTable.json' 
{
    "name": "Students"
}
```
```js
// to read value
var name = $table.name; // "Students"

// to write value to file
$table.name = "New_table_name"; // replaces "Students" in file './testTable.json' 
$table.rows = ["name","class"]; // adds new field "rows" in file './testTable.json'
```
> The `$` sign in the begining of `$table` is an indicator that it is a pure json object (jsonian proxy). I find it useful, to maintain a readable code. If you already use $ for something else feel free to come up with your own convention.

That is it. Your object will always be persisted in file.
## The uglys
It is using javascript Proxy object to capture get/set actions. So assume all the gotchas associated with it.
The project is still in an alpha state. It is untested for the most part. 
This is particularly not recommended for web servers (scalability won't be great with this kind of file write load + I can't think of any usecases) and browsers as long as they don't have filesystem access.
The good part is it all sits in 31 lines of `index.js`.

If you read this far, I think I've earned the right to share git repo [https://github.com/bwowsersource/jsonian](https://github.com/bwowsersource/jsonian)

## Ok how does it work?
When we load a file, it reads the file and parse json to a `rootObj`.
The loader then creates a `Proxy` around this `rootObj`. The proxy intercepts `get` and `set` operations on `rootObj`.
`set`s will trigger a `JSON.stringify` of `rootObj` followed by a write-to-file.
On the other hand `get` will return the value on `rootObject` only if it is not an `object`. If the value being accessed is another object, it will create another proxy around this child object, thus allowing trapping of nested objects.
Étoile du jour: Deploying NASA's Astronomy Picture of the Day on Azure (Microsoft Azure Trial Hackathon)
Tags: azuretrialhack, react, node
Published: 2022-02-20 20:37:04

[Instructions]: # (To submit to the Microsoft Azure Trial Hackathon on DEV, please fill out all sections.)


### Overview of My Submission

A React Single Page Application deployed as an Azure Web App allowing users to select dates from NASA's Astronomy Photo of the Day archive (accessed via a NASA API).

The app is live at: [nasa-apod-picker.azurewebsites.net](https://nasa-apod-picker.azurewebsites.net/)

### Submission Category

Wacky Wildcards

### Link to Code on GitHub

{% github https://github.com/PreciousChicken/azure-react-apod %}

### Additional Resources / Info

#### Screenshot of app:

[![NASA Astronomy Picture of the Day Picker screenshot](https://www.preciouschicken.com/blog/images/azure-react-apod_final-thumb.png)](https://www.preciouschicken.com/blog/images/azure-react-apod_final.png)

#### Accompanying worked example tutorials:

##### Video -
{% youtube b41G09Xft88 %}

##### Blog -
[Étoile du jour: Deploying a React Web App on the Microsoft Azure Cloud](https://www.preciouschicken.com/blog/posts/azure-react-apod/)
React Hooks: useRef()
Tags: react, javascript, beginners, programming
Published: 2022-02-20 20:33:37

**What are React hooks?**
They are functions in React that allow you to add react functionality to function based components.

**What is the useRef hook**
This hook is used to track values between renders and access DOM elements. The main difference between a ref and state is that updating a ref will not cause a re-render. This is especially useful if you want to track the number of renders of a component or when you want to track the previous state of a component. The syntax follows a common pattern:

```js
const refContainer = useRef(0);
//refContainer: {current: 0}
```

- In this case, `0` is the initial value of refContainer.
- refContainer will always be formatted as `{current: someValue}`

Example using useRef to access a DOM node:

```jsx
import { useRef } from "react";

const App = () => {
  let element = useRef();

  const focusButtonClick = () => {
    element.current.focus()
  };

  return (
    <>
      <input ref={element} type="text" />
      <button onClick={focusButtonClick}>Focus</button>
    </>
  );
};

export default App;
```

- All React elements have a `ref` attribute that useRef can access.
- Element is set as `{current: <input type="text" />}`
- When the button is clicked, the input is focused.

Example using useRef to track previous state:

```jsx
import { useRef, useState, useEffect } from "react";

const App = () => {
  const [input, setInput] = useState("");
  const previousState = useRef("");

  useEffect(() => {
    //previousState.current will always update to the previous state
    previousState.current = input;
  }, [input]);

  return (
    <>
      <input
        type="text"
        value={input}
        onChange={(e) => setInput(e.target.value)}
      />
      <p>Current State: {input}</p>
      <p>Previous State: {previousState.current}</p>
    </>
  );
};

export default App;
```

More information about useRef can be found in the React docs: [https://reactjs.org/docs/hooks-reference.html#useref](https://reactjs.org/docs/hooks-reference.html#useref)

Leave comment if you have any questions or feedback.
Hello YouTube.exe
Tags: youtube, devlog, new, programming
Published: 2022-02-20 20:20:11

## Wait what⁉️
I'm starting a software devlog where I take you on the ride with me while creating and troubleshooting my software. 

## Ok, but why though?
Before you click away, hear me out;
I've always believed that in tech, and especially coding, experience is worth more than certifications. 

The problem though, is that it's really hard to show experience on a resume. Yeah sure, you can list what you've done but, if you don't want a 20-page resume, you're going to leave stuff out.

But what if you documented your entire coding journey, what if you can show that you are capable of what you claim? 

## 🦉: "Start a dev blog"
Sure, that's an idea I hear a lot from coding instructors and tutorials, but is it really effective?

The answer is yes...and no.
Of course, documenting your journey in text is documenting, but it's not accessible. 
Hiring managers don't want to scroll through countless articles reading your thoughts. The fact is, people are busy and lazy, and reading takes effort.

BUT, sitting on your couch, watching an entertaining coding journey, now there's an idea the masses can get behind, I know, cause that's me!

## 💸Money? ✨Fame? ☕Free Coffee?
No, don't get caught up in these (although the last one I can support). Remember that your videos are a means to an end. It's a tool to help you in your journey as a developer.

It's the key to unlock a door, the link to make connections and the proof that you can. It's the pudding ❗

Getting caught up in all it is not causes you to lose focus on what it is; it's a documented journey and exploration of your passion...it's just you, sharing what you love 💖

[@EkronMonte on Twitter 🐤:](https://twitter.com/EkronMonte)
> I just posted the trailer for my new YouTube channel. I'm starting a software devlog where I take you on the ride with me while creating and troubleshooting my software. Go check it out 👉 https://youtu.be/a9bnhQh3f4I

### Follow the rabbit 🐰

[New YouTube Channel](https://www.youtube.com/channel/UCnN4L1ZyWo7h5mKDZJgCJqw)

[How Do I Get a C# Developer Job? How Do I Prepare? Do I Need a Portfolio?](https://youtu.be/JnTw3VBz3rg)

[Mistakes New Youtubers Make & 15 Tips to Avoid Them](https://youtu.be/xOpJdHiIwhQ)
Serverless MERN Stack
Tags: serverless, mern, vercel, netlify
Published: 2022-02-20 20:02:41

Convert MERN-Stack to Serverless
Drop-in replace code for Vercel Netlify & AWS Lambda

[App running on Vercel](https://vite-vercel-opal.vercel.app/)

[Github](https://github.com/bronifty/serverless-mern-stack-vite.git)

[Youtube](https://youtu.be/-HfZQNMfAHE)

Note: MERN project samples from [John Smilga Node Projects tutorial (part 1) ](https://www.youtube.com/watch?v=rltfdjcXjmk)
Code Smell 115 - Return True
Published: 2022-02-20 19:53:50

*Booleans are natural code smells. Returning and casting them is sometimes a mistake*

> TL;DR: Don't return true or false. Be declarative.

# Problems

- Readability

- Primitive Obsession

- If/Else abuse

# Solutions

1. Return truth value in a declarative way

2. Replace *IF* With polymorphism.

# Context

Dealing with low-level abstractions, we usually return booleans. 

When we create complex and mature software, we start to forget about this primitive obsession and care about real-world rules and identities.

# Sample Code

## Wrong

[Gist Url]: # (https://gist.github.com/mcsee/973a11295d0d93baa620763dd8eff801)
```java
boolean isEven(int num){
     if(num%2 == 0){
       return true;
    } else {
       return false;}        
}
```

## Right

[Gist Url]: # (https://gist.github.com/mcsee/ab38ef6fcc5dd6dea98f1edb452e75e9)
```java
boolean isEven(int numberToCheck){
  //We decouple the what (to check for even or odd)
  //With how (the algorithm)
  return (numberToCheck % 2 == 0);     
}
```

# Detection

[X] Automatic 

Many linters can check syntactic trees and look for explicit true/value returns

# Tags

- Primitive

# Conclusion

Search on code libraries for *return true* statements and try to replace them when possible.

# Relations

{% post https://dev.to/mcsee/code-smell-36-switch-case-elseif-else-if-statements-h6c %}

# More Info

- [How to get rid of IFs forever](https://dev.to/mcsee/how-to-get-rid-of-annoying-ifs-forever-1jfg)

# Credits

Photo by <a href="https://unsplash.com/@enginakyurt">engin akyurt</a> on <a href="https://unsplash.com/s/photos/flag">Unsplash</a>  

* * *

> The good news is: Anything is possible on your computer. The bad news is: Nothing is easy.

_Ted Nelson_
 
{% post https://dev.to/mcsee/software-engineering-great-quotes-26ci %}

* * *

This article is part of the CodeSmell Series.

{% post https://dev.to/mcsee/how-to-find-the-stinky-parts-of-your-code-1dbc %}