teleren/devto huggingface dataset:
Update HP Laserjet Pro M12a Driver
Tags: driverprinter
Published: 2021-06-24 04:36:31

The power unit hp laserjet pro m12a Printer is syntheticed to supply quality result at some of the regular worth. As a part of the power unit assortment, you get all the integrity and conjointly performance you'd actually anticipate from the printing market’s market leader. specifically what’s even additional, for a printer of its dimension, it’s remarkably productive– able to generate a full eighteen websites every min. As a results of its transportable dimension, if space goes to a prices at either residence or job, perhaps the optimum remedy for the task.

The power unit hp m12a Printer Equipped with the relied on initial power unit printer toner cartridges, the M12a corresponds and conjointly trustworthy, while providing a fine quality potency. the power unit hp laserjet pro m12a Printer sceptered by USB association, you'll extremely simply link to a laptop or Notebook, indicating it’s easy along side reliable. you'll to boot manage double-sided printing due to its active duplex various

Source: https://khasoft.com/hp-laserjet-pro-m12a-driver-software/
What does a machine learning toolbox consist of ?
Tags: machinelearning, tools
Published: 2021-06-24 04:11:18

---
title: What does a machine learning toolbox consist of ?
published: true
description: 
tags: machineLearning, tools
//cover_image: https://direct_url_to_image.jpg
---

(This is a placeholder for my exploration of various tools used in the machine learning ecosystem)

As we consider machine learning projects, from end to end fashion, following are some of the phases and based on each phase, we have different toolsets which enable the engineer to perform the data processing in each phase.

##### Phases in Machine Learning project

1. Data ingestion
2. Data exploration
3. Data analysis
4. Data visualization
5. Model training
6. Model testing
7. Model deployment
8. Model serving
9. Model logging/healthchecks etc

##### Tools used in each phase

(unordered by its usage)

1. Python
2. numpy
2. Tensorflow
3. Apache Spark
4. pandas
5. R
6. SAS
7. jupyter notebooks
8. kubeflow


Learning continues...
Create React DateRangePicker in 5 Minutes
Tags: daterangepicker, reactnative, webdev, component
Published: 2021-06-24 03:25:34

Learn how easily you can create and configure the Syncfusion [React DateRangePicker](https://www.syncfusion.com/react-ui-components/react-daterangepicker "React DateRangePicker") using the create-react-app command. This video also explains how to configure a few of the control’s basic features like setting specific date range values, range restriction, formats, and month range picker.

**Download an example from GitHub**:
http://bit.ly/2OWNTXP

**Refer to the following documentation for the Syncfusion React DateRangePicker**: 
http://bit.ly/3tkjJws

**Check out this online example of the React DateRangePicker**: 
http://bit.ly/30RXoKh

{% youtube RCC_K6FbZRU %}
Básico do Básico de HTML5!
Tags: html, brasil
Published: 2021-06-24 03:13:37

<hr/>
Notas do editor:
"A principio gostaria de dizer que ainda sou um mero estudante e continuarei sendo nessa vida que escolhi ter, pois nunca paramos de aprender nessa área.
Sendo assim, se tiver alguma sugestão, algo a complementar ou corrigir algo em meus resumos, fique a vontade.
Estou fazendo isso para melhorar meu aprendizado e passar o conhecimento que adquiri! Sendo assim, tenha um belo dia! <3"
<hr/>

Bom, você ai que quer entrar no ramo da programação mas não sabe por onde começar ou quer ter a primeira experiência, aqui vai uma dica que eu dou, e que provavelmente nem irá precisar instalar uma IDE para tal. (Caso não saiba o que é uma IDE ou o básico das outras coisas e quer saber mais, da uma olhada no perfil do https://dev.to/darrow)

A principio vamos saber o que significa HTML5:
HTML (Hyper Text Markup Language) é nada mais nada menos do que:
- Um arquivo que contem marcadores (tag).
- Essas tags indicam para o navegador (browser) como a página deve ser apresentada.
- Marcadores usualmente vem em pares ```<tag>...</tag>```
- Também podem aparecer de forma abreviada como: ```<tag atributo="valor".../>```

<hr/>
Agora, vamos compreender um pouco das tags que utilizamos no html5, lembrando, apenas o básico!

```<html> - Define um documento HTML, tudo que estiver nele será apresentado no navegador.```

```<head> - Define e configura o topo do seu site/código, como o título e outros```

```<title> - Define o título do seu site, que fica nas abas do navegador```

```<body> - Define o corpo do HTML, tudo que estiver nele será visível no site.```

```<h1> até a <h6> - Define cabeçalhos de 1 a 6```

```<p> - Define um parágrafo.```

```<br> - Define uma quebra de linha.```

<hr/>
Sendo assim, vamos fazer o seu primeiro site?

Abra seu bloco de notas e escreva isso aqui:
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c2nehnym4lhrser0vre9.png)

Após finalizar, salve-o como "index.html" e execute-o, se você fez tudo certinho, o site irá aparecer dessa forma:
![image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kttyc8eunuczexeiy04i.png)

<hr/>
Espero que você tenha consigo realizar o seu possível primeiro site de muitos outros.
Não se esqueça de fuçar nesse código e entender mais um pouco sobre o que cada tag faz e etc.
Agradeço se leu até aqui, um abraço e até a próxima!
ERC20: El estándar de Tokens en el Blockahin
Tags: ethereum, solidity, blockchain, defi
Published: 2021-06-24 03:00:48

---
title: ERC20: El estándar de Tokens en el Blockahin
published: true
description: 
tags: #ethereum, #solidity, #blockchain, #defi
//cover_image: https://direct_url_to_image.jpg
---

{% youtube V4pmABnQbLQ %}

Los ERC20 son el estándar de tokens en todos los blockahins compatibles con la Ethereum Virtual Machine. En este video creamos nuestro propio Token y realizamos operaciones mediante un segundo Smart Contract operador.

# Contrato de Token ERC20

```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.5;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.1.0/contracts/token/ERC20/ERC20.sol";

contract MyERC20 is ERC20 {
  uint256 public token_transfer_count = 0;

  constructor () ERC20("Token", "TKN") {
    _mint(msg.sender, 1000 ether);
  }
    
  function mint(address account, uint256 amount) public {
    _mint(account, amount);
  }

  function burn(address account, uint256 amount) public {
    _burn(account, amount);
  }

  function _beforeTokenTransfer(address from, address to, uint256 amount) internal override
  {
    token_transfer_count += 1;
  }
}
```

# Contrato Operador

```solidity
// SPDX-License-Identifier: MIT
pragma solidity 0.8.5;

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.1.0/contracts/token/ERC20/ERC20.sol";

contract MyERC20Operator {

  mapping (address=>uint) public balances;
  ERC20 my_erc20;

  constructor (address my_erc20_address)
  {
    my_erc20 = ERC20(my_erc20_address);
  }

  function deposit(uint amount) public
  {
    my_erc20.transferFrom(address(msg.sender), address(this), amount);
    balances[msg.sender] += amount;
  }

  function retrieveTokens() public
  {
    my_erc20.transfer(address(msg.sender), balances[msg.sender]);
    balances[msg.sender] = 0;
  }
}
```

[Documentación oficial](https://docs.openzeppelin.com/contracts/2.x/erc20)

**Gracias por ver este tutorial!**

Sígueme en dev.to y en [Youtube](https://www.youtube.com/channel/UCNRB4tgwp09z4391JRjEsRA) para todo lo relacionado al desarrollo en Blockchain en Español.
What do JavaScript devs need to know about Fintech development?
Tags: fintech, javascript, crypto, blockchain
Published: 2021-06-24 02:39:17

A brief introduction:

I work in the European fintech space, on a platform that's an API of APIs that helps fintech businesses get off the ground quickly. 

Even though my coding skills are pretty decent, I find that my real challenge starting out were mostly connected to my limited understanding of the financial industry as a whole. I've been bridging that gap by taking courses on financial markets, business models and technologies but I'd like to know from more experienced developers in the fintech space.

How did you get knowledgeable, and what would you say was the most important route to gaining this competence?
How to become a self-taught programmer
Tags: beginners, programming, productivity, codenewbie
Published: 2021-06-24 02:36:09

## 1. Where to start
The first step of programming is to decide on which language to learn first. And that is the most common problem that occurs to anyone who wants to learn programming.
There are so many programming languages and technologies that are famous and widely used nowadays. But rather than selecting the one which is famous, you should focus on the technology you are interested in working with.
There are so many language options and technologies, to begin with. And if you are learning programming as a career option carefully choose a path. because it takes time to learn a language or technology and you won’t like to drop it in between.
So choose your field wisely.

## 2. Finding Perfect Resources
After choosing the language you want to work on you have to find perfect resources to learn the language. There is a vast ocean of information and knowledge on the internet. But to find the perfect resource to begin is difficult.
There are websites that offer courses in various languages. YouTubers have whole playlists for various topics related to programming, blogs, online books.
You have to choose the best one for you among them. So that you can not just remember things but also understand every topic.

## 3. Acquire Basic knowledge
If you want to learn programming on your own you have to be familiar with some basics of computer and programming. For example, if you want to start a business you have to gather all the information related to the field you want to work on.

[read more](https://www.codesnail.com/steps-to-become-a-self-taught-programmer/)
What was your first code editor?
Tags: discuss, watercooler, beginners, codenewbie
Published: 2021-06-24 02:29:10

# Introduction

Today, we have known many code editors that offer more than a just code editor. They have many features and support for extensions to increase their features. 

![Coding](https://media.giphy.com/media/QHE5gWI0QjqF2/giphy.gif)

Back to when we code the first time, we were having less idea about code and code editor. So we used whatever was best or recommended.

So today, let's share about our first code and code editor.

## My Experience 

- [Batch Scripting Language](https://dev.to/surajondev/what-is-the-first-programming-language-that-you-learned-1enc) was my first programming language. I used it to code my first program that was **Hello World!**
- The Code Editor that I used was **Notepad**
- No feature of a modern code editor, it was only me and notepad

## Discuss

- What was your first experience with code and code editor?

## 🔗 Connect with me:

Currently, on Twitter, I am posting about "How to write and grow blog?". If you want to write a more effective blog with tips, consider the follow button on Twitter.

<blockquote class="twitter-tweet"><p lang="en" dir="ltr">With this completing 500 tweets🥳.<br><br>Thank you to everyone🤩.<br><br>As helping more people, I am going to tweet about writing and growing blog especially technical, in the coming days🔥.<br><br>So if you haven&#39;t followed me, please consider🤗.</p>&mdash; Suraj Vishwakarma [@surajondev](https://twitter.com/surajondev) <a href="https://twitter.com/surajondev/status/1394212368675000321?ref_src=twsrc%5Etfw">May 17, 2021</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

[**Twitter**](https://twitter.com/surajondev)

## Last Note

I am excited to read your experience.
CSS Combinators: Siblings
Tags: beginners, css
Published: 2021-06-24 00:24:49

Welcome to the third entry in my series of CSS combinators. In this entry we will go over the adjacent sibling combinator and then next week will be the finale, the general sibling combinator. 

The adjacent sibling operator(aso from this point on) can be identified with its use of a '+' in between two CSS selectors. As we always do, lets setup an example to follow along with.

```
<div class='dr-light'>
 <h1>Dr.Light's Family</h1>
   <p class='mega-man'>
   <p class='roll'>
   <p class='proto-man'>
</div>
```

One way to use the aso in CSS could be like this:

```
h1 + p {
  something:blah blah
}
```

Within this example we want the css inside the block to effect any siblings that may follow an h1 tag that will be a p tag. However, that wont work in this case. the h1 tag ACTUALLY is the parent of the following p tags within the html document. So while the idea is right...this wouldn't change anything on the document. If we changed the above mistake into:

```
p + p {
  something:blah blah
}

```
The HTML would be affected, but the only tags that would be affected are the 2nd, and 3rd. They both are adjacent siblings of the p tag, while the first sibling is not. Another cool way to declare some kind of specificity within CSS. 

As always, give is some practice and HAPPY CODING!!
Whoever Does Stripe's Technical Writing Deserves an Award
Tags: webdev, startup, beginners
Published: 2021-08-10 16:30:35

---
title: Whoever Does Stripe's Technical Writing Deserves an Award
published: true
date: 2021-06-24 00:00:00 UTC
tags: [ webdev, startup, beginners ]
canonical_url: https://thomasstep.com/blog/whoever-does-stripes-technical-writing-deserves-an-award
---

I’ve been playing with Stripe lately as a payment processor for some of my projects, and their documentation is by far the best I have ever read. The integration experience is extremely easy thanks to what they have written. The message is clear and concise. The animations bring value to the page with my personal favorites being those that highlight which pieces of the code snippets the documentation is referencing. Overall, working with their service is much easier and more fun thanks to their documentation. They obviously put a huge emphasis on the developer experience.

For any developers out there with some time on their hands (I know, it’s rare), please go through their documentation or try to integrate an application with their API. It’s worth going through even if you never plan on using them just to know what we are missing out on with respect to a beautiful developer experience. The overall flow and information provided are amazing.

My favorite part is in the [API docs](https://stripe.com/docs/api) specifically. If you are signed in, the page fills in the example requests and payloads as the page scrolls through with information relevant from your account. I’m guessing they use recent events, customer information, or account data, but I’m not completely sure how they do it. For example, after I configured a webhook and scrolled down to [the webhook endpoint object portion](https://stripe.com/docs/api/webhook_endpoints/object), my newly created webhook information was shown. Those little pieces are worth a lot to me and I’m glad they put them in to enhance to documentation and integration experience. Well done Stripe!
The hidden costs of hiring too fast
Tags: practices, culture, hiring, team
Published: 2021-06-28 06:49:28

---
title: The hidden costs of hiring too fast
published: true
date: 2021-06-24 00:00:00 UTC
tags: practices,culture,hiring,team
canonical_url: https://jhall.io/archive/2021/06/24/the-hidden-costs-of-hiring-too-fast/
---

Last year I worked with an early stage VC-funded startup. When my contract begain there were probably 8 engineers across all disciplines (frontend, backend, mobile, etc). I set out to begin instilling quality, through mentoring, defining engineering guidelines, setting up automated hands-off deployments etc.

I felt I was really making great progress, until the pressure from above started coming down to “hire more people!”

On the one hand, this was understandable, at least superficially. We had certain product goals to meet, and we weren’t meeting them with the current engineering team.

On the other hand, from a more holistic view, the current team had _just_ formed, and was only beginning to go through the [storming](https://en.wikipedia.org/wiki/Tuckman%27s_stages_of_group_development) stage. Expecting “performing” results from such a team is just unrealistic.

So the approach dictated to us was to hire as many new joiners as humanly possible (within budget—which was quite large).

The end result is that most of the progress I had made on instilling a culture of quality and excellence, of peers holding each other accountable for high standards, etc, was almost entirely lost within a 3-month time period.

Perhaps an argument can be made that this was the right decision for the company. Maybe for an early-stage VC-funded startup, this is the “right way” and the benefits outweigh the costs. This will have to be determined by those with more than one datapoint.

What I’m certain of is that this approach has a high cost. The human cost in this case was evident by the tremendous turnover that ensued—at one point, more than 10% of the entire company left in the same week (the same week my contract ended). The technical cost is manifest as technical debt, bugs, and unreliable software without quality built in from the beginning.

If you find yourself tempted to hire large numbers of people for your project, just be absolutely sure you know the cost this entails, and make an _informed_ decision about wether the potential benefits are worth the high cost.

* * *
_If you enjoyed this message, [subscribe](https://jhall.io/daily) to <u>The Daily Commit</u> to get future messages to your inbox._
3 markdown editing tips I wish I knew when I started my dev blog
Tags: markdown, blogging, webdev
Published: 2021-06-24 16:02:15

---
title: 3 markdown editing tips I wish I knew when I started my dev blog
published: true
date: 24/06/2021
tags: #markdown #blogging #webdev
canonical_url: https://darraghoriordan.com/2021/06/24/three-3-markdown-editing-tips/
---

I write markdown documentation everyday. I use it for documentation at work and I use it for my blog. I love the simplicity of it.

Over the years I’ve learned theses tips and I wish I knew them when I started.

<!-- end excerpt -->
## 1. draw.io vscode and the .svg format

If you need to create a diagram for your document you should consider draw.io. There is a drawio plugin for vscode that makes it easy to diagram directly in the vscode UI. 

After you install the plugin you can just create a new file with a `.drawio` extension and start drawing. To import a drawio diagram into a markdown document you have to export the diagram to a format that can be used in documents like png.

My tip here is to use the `.drawio.svg` format instead of `.drawio` so most markdown viewing tools can read the diagram directly off your diagram. This is really great for GitHub documentation.

So to use, create a new drawio diagram file and add svg at the end. e.g. File > new > `myDiagram.drawio.svg`.

Then you can reference this in your markdown directly `![My diagram]("./myDiagram.drawio.svg")`.

## 2. You don’t have to number your sequential lists properly

If you are creating an ordered list you DON’T have to order it. You can just use `1.` for all elements and markdown will figure out the order. 

Not specifying the order makes it much easier to change the contents of the list later.

e.g.

```
// this is GOOD - markdown will figure out the order when this is viewed.
1. list item
1. list item
1. list item

// this is BAD - we deleted one and broke the order
1. list item
2. list item
4. list item
```

## 3. Square peg in a round hole

I always forget the order of the brackets to describe a link or an image in markdown. 

An easy way to remember is “square peg in a round hole” - square brackets always come first.

```
// for an image
![My image]("./this-is-an-image.png")

// for a link
[This is my link]("https://thisismyurl.com")

That's it! Do you have any markdown tips?
```
Javascript Questions
Tags: javascript, beginners, interview, intermediate
Published: 2021-06-23 23:43:36

let a = 3;
let b = new Number(3);
let c = 3;

console.log(a == b);
console.log(a === b);
console.log(b === c);


A: true false true
B: false false true
C: true false false
D: false true true

Answer: C

new Number() is a built-in function constructor. Although it looks like a number, it's not really a number: it has a bunch of extra features and is an object.

When we use the == operator, it only checks whether it has the same value. They both have the value of 3, so it returns true.

However, when we use the === operator, both value and type should be the same. It's not: new Number() is not a number, it's an object. Both return false.
Crude Python tree shaking for squeezing into AWS Lambda package size limits
Tags: python, aws
Published: 2021-06-23 23:19:03

I have been working on a service that manages a number of Machine Learning workloads that is deployed to AWS Lambda. One of the issues I encountered deploying this service is our dependency on a number of popular ML related Python modules such as `pandas` and `scikit-learn` and exceeding the maximum size thresholds imposed by AWS. AWS enforces a 250 MB hard limit on Lambda packages and `scikit-learn` alone is 100 MB unzipped. Deploying yields:


> ServerlessError: An error occurred: Resource handler returned message: "Unzipped size must be smaller than 262144000 bytes (Service: Lambda, Status Code: 400)"

There doesn't seem to be many options for slimming down dependencies, I was hoping to find subtree splits of the submodules that were relevant to our project, but came up short. I had already configured the `serverless-python-requirements` plugin to slim down packages:

```
custom:
  pythonRequirements:
    slim: true
    strip: false
```

Note: the `strip: false` option was required to prevent an error during execution which manifested as:

> Runtime.ImportModuleError: Unable to import module 'handler': /var/task/scipy/linalg/_fblas.cpython-38-x86_64-linux-gnu.so: ELF load command address/offset not properly aligned

One option to reduce the footprint of dependencies is to implement some form of tree shaking, to remove chunks of code we're not actually using, the tricky part would be to identify which parts those are. In our case, we had already 100% test coverage, so we were able to use this coverage and run a report against our dependency folder (instead of our src folder) to find out which parts of our dependencies we were actually using:

```
poetry run pytest --cov-report=html\
 --cov=/path/to/site-packages
```

Running this report indicates about %6 "coverage" of our dependencies:

![Screen Shot 2021-06-23 at 7.26.12 pm](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/e0ujhlmgijjhuvdnbxv7.png)

From here, it was a simple matter of taking a snapshot of files with 0% coverage and removing them from our artefact. To accomplish this, I found the `serverless-scriptable-plugin` [was required to remove dependencies](https://github.com/UnitedIncome/serverless-python-requirements/issues/138) added by the `serverless-python-requirements` plugin. 

### serverless.yml:
```
plugins:
  - serverless-python-requirements
  - serverless-scriptable-plugin
...
custom:
  pythonRequirements:
    slim: true
    strip: false
  scriptable:
    hooks:
      after:package:createDeploymentArtifacts:
        - ./shake.sh
```

### shake.sh
```
#/bin/sh
filelist="_distutils_hack/__init__.py
_distutils_hack/override.py
...
wheel/util.py
wheel/vendored/packaging/_typing.py
wheel/vendored/packaging/tags.py
wheel/wheelfile.py"

for file in $filelist
do
  zip --delete ./.serverless/data-science-api.zip $file
done
```

In the end 28,000 unnecessary files were removed and the artefact was reduced from 307 MB to 236 MB, unblocking deployment.