teleren/devto huggingface dataset:
Self-supervised Learning, Future of AI
Tags: ComputerVision, DeepLearning
Published: 2020-03-13 13:01:00

![self-supervised learning: patch positions](http://perfectial.com/wp-content/uploads/2020/03/SSL-03-scaled.jpg)

Self-supervised learning is one of those recent ML techniques that have made waves in the data science community, but have so far been flying under the radar as far as Entrepreneurs and Fortunes of the world go; the general public is yet to learn about the concept but lots of AI folk deem it revolutionary.

The paradigm holds vast potential for enterprises too as it can help tackle deep learning’s most daunting issue: data/sample inefficiency and subsequent costly training.

We believe strongly that, as a business owner, you should acquaint yourself with this inherently complex subject and we’ll gladly help.

##Hand-crafted Feature Learners and Deep Learning Systems: AI Past vs AI Future

These days, when someone mentions AI’s transformative potential, they’re likely speaking about machine learning. And when you’re reading another sensationalist post about the groundbreaking progress in ML, the authors are probably referring to deep learning (and supervised deep learning in particular).

Since human-generated features tend to be brittle, the AI community is increasingly embracing deep learning systems (for a number of tasks), which can learn data’s distinctive properties by themselves given an objective function.

These neural nets aren’t magic, though, they’re just cleverly applied statistics and algebra.

The basic build of a deep learning system includes a succession of linear and point-wise non-linear operators. Neural nets first encode every input, turning into a vector or a list of numbers, then do computations on the received values using various matrices in their neurons (which their layers consist of) and, afterward, pass the resulting vectors through a bank of nonlinear functions (such as ReLU) and a classifier at the very end of the architecture.

When the machine fails to output what is expected of it (a correct class/label in supervised learning), data scientists can tweak the network’s parameters (all the modules are trainable) until the results are satisfactory. This is done via gradient descent which, in turn, is computed by a backprop algorithm.

It turns out computers are exceptionally good at learning functions that map inputs to human-generated labels under one condition: an enormous amount of labeled data must be fed to them first. There’s also another drawback: these models, determined to classify the input into a category, don’t learn much about the inherent properties of input elements. The feedback the machine is given is scarce in supervised learning, so naturally the networks are very sample inefficient.

This creates a significant issue: high-quality data is often hard to come by for a lot of companies and obtaining an annotated dataset can prove too costly an undertaking even for large organizations.

The post [Self-supervised Learning, Future of AI](https://perfectial.com/blog/self-supervised-learning/) appeared first on [Software Development Company Perfectial](https://perfectial.com/).
Daily Developer Jokes - Friday, Mar 13, 2020
Tags: jokes, dailydeveloperjokes
Published: 2020-03-13 13:00:30

---
title: "Daily Developer Jokes - Friday, Mar 13, 2020"
description: "Check out today's daily developer joke! (a project by Fred Adams at xtrp.io)"
series: "Daily Developer Jokes"
cover_image: "https://private.xtrp.io/projects/DailyDeveloperJokes/thumbnail_generator/?date=Friday%2C%20Mar%2013%2C%202020"
published: true
tags: #jokes, #dailydeveloperjokes
---

Generated by Daily Developer Jokes, a project by [Fred Adams](https://xtrp.io/) ([@xtrp](https://dev.to/xtrp) on DEV)

___Read about Daily Developer Jokes on [this blog post](https://xtrp.io/blog/2020/01/12/daily-jokes-bot-release/), and check out the [Daily Developer Jokes Website](https://dailydeveloperjokes.github.io/).___
### Today's Joke is...
![Joke Image](https://private.xtrp.io/projects/DailyDeveloperJokes/public_image_server/images/5e12597d4e1c1.png)

---
*Have a joke idea for a future post? Email ___[xtrp@xtrp.io](mailto:xtrp@xtrp.io)___ with your suggestions!*

*This joke comes from [Dad-Jokes GitHub Repo by Wes Bos](https://github.com/wesbos/dad-jokes) (thank you!), whose owner has given me permission to use this joke with credit.*

<!-- 
Joke text:
___Q:___ What accommodations did the JavaScript developer request at the hotel?

___A:___ A room with a Vue.
 -->
Distributing operational knowledge across a team
Tags: todayilearned, testing, programming, leadership
Published: 2020-03-13 13:00:23

*TL;DR notes from articles I read today.*

### [Distributing operational knowledge across a team](http://bit.ly/3aT8VfC)

- Knowledge management isn’t just a concern for larger companies. Small teams can & should adopt knowledge management practices and tools right from the beginning. It helps in building a scalable team and an effective on-boarding of new members to the team. 
- Start building your knowledge repositories. These are for information needed in the long term by many different team members. 
- To begin with, use simple tools for task management and collaboration and you can always move to a more feature-rich tool if and when you need to. To make sure people actually use a tool, make the tools usable and relevant and offer any necessary training needed for your team to get comfortable with the tool. Define expectations around particular tools for particular tasks, so that work or concerns are not addressed unless logged with that tool. 
- Find a comfortable signal-to-noise ratio of communication: start with more communication and gradually filter out what you realize you don’t need, rather than missing out what you didn’t know you need to know.
- Remember the importance of face-to-face contact as well, in person or via VoIP, for clarifications, resolving long-standing issues and building morale. For teams across time zones, make these meetings asynchronous or organize several meetings at different times to allow a fair spread for participation. 

*[Full post here](http://bit.ly/3aT8VfC), 9 mins read*

---

### [Things to remember before you say yes to automation testing](http://bit.ly/2IK5yvi)

- All tests can’t be and shouldn’t be automated. Know which tests, if automated, will stop finding bugs and keep them out of the automation list. 
- Work on well thought out and well-defined test cases before starting to build test automation. 
- Use the programming language your testers are familiar with to keep the learning curve not too steep. 
- If test automation gives ambiguous results, don’t consider it. There must be a problem with the test script or test plan. Look at solving that problem. 
- Break your test suite into smaller chunks of independent test cases that don’t affect the results of other test cases. 

*[Full post here](http://bit.ly/2IK5yvi), 6 mins read*

--- 

*[Get these notes directly in your inbox every weekday by signing up for my newsletter, in.snippets().](https://mailchi.mp/appsmith/insnippets?utm_source=devto&utm_medium=post08&utm_campaign=is)*
Flutter development coming from a web background
Tags: webdev, flutter, dart
Published: 2020-03-13 12:20:22

I delved into flutter on the 17th of February 2020. Since then, I've been trying to understand how to:
1. Build layouts
2. Handle state changes
3. Save user data to disk

So far, I'm still confused about how many things work in Flutter. I'll talk about several aspects of Flutter development.

# Dart
For starters, the dart language, though friendly, prevents seamless development. Probably because I don't know it in-depth. 
Having been using JavaScript for over a year, I've become accustomed to the functional approach JS devs use to write business logic. 
In Dart, most things are done in classes. 

# Errors and Debugging
One thing I enjoy about web development is the ease of debugging. This is probably due to familiarity. For the most part, I believe familiarity is all that is needed for any developer. Most times, I have no idea on the error message the dart interpreter is emitting.

# Ease of development
Building web applications is simplistic. Especially when you aren't using a framework. All you need to do is write a bunch of markup and a few structures, style this markup and finally, make it interactive (frontend in this case). 
Flutter offers a different approach. Here almost everything is a widget, even styles. I actually dislike Styled Components. Seeing it in Flutter feels like _I've met what I've always been running from_.

Now, the fact that flutter compiles to several platforms is truly amazing. If you need a web version of your app, you don't need to write extra code. You just run the web build command!

I hope to get familiar with Flutter and Dart. I read somewhere that the best way to learn is to teach. I'll follow this approach to teach flutter on blogs and in workshops. Thanks for reading.
Web Dev Book Club: The Lean Startup
Tags: books, career, watercooler, startup
Published: 2020-03-14 18:05:11

---
title: Web Dev Book Club: The Lean Startup
description: The Lean Startup by Eric Reis teaches you the modern way to build a business. With this knowledge, you can transform from 'web dev' to high-paid 'consultant!'
published: true
date: 2020-03-13 12:13:00 UTC
tags: books,career,watercooler,startup
canonical_url: https://raddevon.com/articles/web-dev-book-club-the-lean-startup/
cover_image: https://dev-to-uploads.s3.amazonaws.com/i/nu2xgojx18gln8paq3kj.jpg
---
{%youtube mNE8mKfK3XA %}

The Lean Startup
----------------

Grow as a web developer by reading [_The Lean Startup_](https://amzn.to/2PZUCxP) by Eric Reis. Yes, it’s a business book, but you’ll be a much better web developer after reading it.

The old way of starting a business was to come up with an idea, go away for months to build it, and finally release it **with your fingers crossed** 🤞. _The Lean Startup_ teaches you a new method that **removes a lot of the risk** and **makes building a new business cheaper**. Here’s what you’ll learn as a web developer:

*   💸 Building everything at once is a bad (and expensive) idea. Build your projects incrementally and save your clients/employers money by recommending they do the same.
*   💼 Learning the techniques of The Lean Startup is critical if you’re going to be working with startups (because they’re most likely building their companies on the foundation of this methodology). If you’re not working with startups, you can start to share these lessons with your clients. They’ll see you less as a “developer” and more as a “consultant.” This means you have a greater chance of delivering them success and you can charge more money.

Grab your copy [on Amazon](https://amzn.to/2PZUCxP).

Your next step is to stop reading about web development and make it your career. Start with freelancing. My [Freelance Crash Course](https://raddevon.com/enroll-in-the-freelancing-crash-course/) will teach you how.
VSCodium(VSCode) extensions to make working with Vue easier
Tags: vscode, productivity, vue, javascript
Published: 2020-03-13 12:09:39

Hi everyone,

Today I want to list some extensions that can make Vue development easier with VSCodium.

The following extensions are recommended for Vue:

- Vetur [Vetur link](https://marketplace.visualstudio.com/items?itemName=octref.vetur)

- ESLint [ESLint link](https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint)

- Prettier [Prettier link](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)

- Vue VSCode Snippets by *Sarah Drasner* [Vue VSCode Snippets link](https://marketplace.visualstudio.com/items?itemName=sdras.vue-vscode-snippets)

- Vue VS Code Extension Pack by Sarah Drasner [Vue VS Code Extension Pack link](https://marketplace.visualstudio.com/items?itemName=sdras.vue-vscode-extensionpack)

- Rainbow Indent [Rainbow Indent link](https://marketplace.visualstudio.com/items?itemName=oderwat.indent-rainbow)

- Auto Rename Tag [Auto Rename Tag](https://marketplace.visualstudio.com/items?itemName=SimonSiefke.auto-rename-tag)

**Bonus** 

Use `serve -s dist` to preview your Vue builds before you upload them to production

You can install serve with `yarn global add serve` or `npm i -g serve`

Theme: Night Wolf [Night Wolf Link](https://marketplace.visualstudio.com/items?itemName=MaoSantaella.night-wolf)

> Warning: Disable Vetur snippets if you are also using the Vue VSCode Snippets by *Sarah Drasner*. DO NOT DISABLE VETUR COMPLETELY.

A step by step guide can be found here https://www.vuemastery.com/courses/real-world-vue-js/optimizing-your-editor/.

I hope you enjoyed the artcile **Dear Reader**.
Also, if you liked the article, than share it with others on social.

Credits:
https://www.vuemastery.com/courses/real-world-vue-js/optimizing-your-editor/
🚀 Process Monitor for Node.js
Tags: node, javascript, webdev, showdev
Published: 2020-03-13 12:02:52

We just released **v2.2.0** of [Ultra Runner](https://github.com/folke/ultra-runner) with a new monitoring feature! Running `ultra --monitor` will show a process list similar to `top`, but only for **Node.js** processes.

### :sparkles: Features

* **sorted** by CPU usage
* **tree** view of parent/child processes
* **package** or directory where the command was executed
* **cpu & memory** usage
* **clean** command line (use regular `top` to see the messy difference :smile:) 

> Should work on Macos & Linux and *probably* on Windows (let me know if you have any issues)
Week 0: Security blog posts introduction
Tags: security, infosec, blogpost, pentest
Published: 2020-03-13 10:28:08

---
title: Week 0: Security blog posts introduction
published: true
description: Introduction to infosec-related blog posts!
tags: #security #infosec #blogpost #pentest
---

Hi! My name is Juanjo and as some of you may know, I’m a Software Developer at The Agile Monkeys. From the last year or so (early 2019), I began my path into the penetration testing world and I have to be honest, I’m loving every piece of it. That’s why today, approximately 1 year after, I decided to write about some stuff I have found interesting during this amazing year (plus new things I will learn of course).

You might be asking what a penetration test is (otherwise just skip this paragraph). A penetration test is a process of studying/analyzing a system with the objective of finding existing vulnerabilities and reporting them back to the system’s owner (so they can fix them). You can check an example of what a penetration test report looks like here: https://www.offensive-security.com/reports/sample-penetration-testing-report.pdf

First of all, I want to clarify that I’m not a penetration tester and I’m not even close to being a pro at all, but I consider that I have studied enough to talk about certain topics or at least the initial/intermediate steps of it. So first of all, I would like to clarify how this is going to be organized:
- I will write about a different topic from every Thursday afternoon/evening to the next one. That means that you will have something to read every Thursday. 
- These posts will not be organized as chapters, and I will probably explain different and unrelated things every time. This is because the beginning part of it could get really tedious to follow.
- The objective is not only me teaching you stuff, but you also participating in the comments so we can all share our knowledge. Maybe we can all learn something new!

So, let the write begins!!
Do you have a strong reason to use NPM or Yarn (or something else)?
Tags: javascript, node, discuss
Published: 2020-03-13 11:41:14

For some differences I have found,

Pro-Yarn

- Work better with Nuxt TypeScript -- [Not sure if this is the right issue.](https://github.com/nuxt/typescript/issues/175)
- "resolutions" -- https://stackoverflow.com/questions/52416312/npm-equivalent-of-yarn-resolutions

Pro-NPM

- Work better with `eslint --init` -- [Not sure if this is the right issue.](https://github.com/eslint/eslint/issues/9863)
- `npm install ../package` uses symlink instead of copy. -- This is the case for me. I don't want to use the **invisible** `yarn link`

I don't much about `something-else`, like [pnpm](https://pnpm.js.org/)...

Anyways, if you need to enforce use Yarn only, there is [has-yarn-cli](https://github.com/sindresorhus/has-yarn-cli), and I have cloned it for NPM -- [is-npm-cli](https://github.com/patarapolw/is-npm-cli).

Put this in `package.json`

```js
{
  "preinstall": "has-yarn",
  // Or, "preinstall": "if !(test -x has-yarn); then has-yarn; fi",
  // If you want to prevent running this on the remote server
}
```

Of course, the way without using any packages is

{% stackoverflow 41076172 %}
Getting Mentally and Physically Ready for a Long Term Project
Tags: psychology, productivity, health, burnout
Published: 2020-03-13 11:15:44

Before I get cranking for the day, I want to mention a few things to make myself aware of the psychological/physiological implications of this undertaking.

Most of my products as [Marc Ignac](https://twitter.com/marcinignac/status/1238129028411858944) showed in an illustration yesterday have ended up in the debugger's valley and rarely manage to crawl out of this pit to deliver long term value.

![Hype Cycle](https://dev-to-uploads.s3.amazonaws.com/i/cbsu7is2tl9vxonlu8h0.jpg)

So I want to begin by sharing some preparatory resources that I want to mention here to keep me committed to this:

1/ Help your future self by managing what’s on your plate. Each day you procrastinate is extending the load a bit more, potentially causing your future self to abandon the project seeing the mess you have made.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/malvk1ifwayqbndwt30d.jpg)

2/ There’s going to be a lot of work than you have anticipated and only by working your due can you arrive at a polished product that will be valuable to the community. But you got to do the due.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/lvrjeu431t4ph5q3ihnx.png)

Also, to be sober about this, most of these things are fractal/recursive as detailed in [Hofstadter’s law](https://en.wikipedia.org/wiki/Hofstadter%27s_law). Also, there’s a good chance that the [99 rule applies here](https://en.wikipedia.org/wiki/Ninety-ninety_rule): last 10% of the work taking 90% of the time.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/qnx39q79fvm3tq6iff2o.gif)

3/ **Less Talk. More Rock**. You need to be replenished enough mentally and physically to do this long grind. This is a [really good post](https://boingboing.net/features/morerock.html) by Superbrothers who made one of the most swagass game out there called Sword and Sworcery.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/3uugwzi3n62bhvh6c7tt.png)

The time you allot for the project shouldn't narrow enough just to finish the stuff on time, but **wide enough** to accommodate time to refresh yourself physically and grant you a clear mental space. Regular exercise and a lot of sleep is highly recommended to prevent pernicious psychological crash and burnout.

Devotion and commitment will be their own reward in this. Discipline and responsibility I have noticed act as a structure to direct the focus towards the goal. One should also be vigilant that the structure doesn't becoming a stricture but leaves enough room for creative exploration and rejuvenation.

There would be challenges, agonies, breakthroughs, and delight along the way. But to arrive at all these, relentless commitment to the task at hand and a lot of uninterrupted free time is needed.

Now that I have put out a sort of mini-guide psychological nature of all this, it is time to get into the specifics of building the project. In the next post, I will write about just that.
Promises in Node.js: .then vs. async/await
Tags: node, javascript
Published: 2020-03-13 01:05:40

# Overview

In this post, I'll contrast two code snippets. I came across these when helping a friend refactor a Node server they'd set up. Each code snippet is a valid approach to writing a create action for a resource on a Node server. One approach uses a chain of .then's to handle asynchronous code, and the other approach uses async/await. 

## A word on asynchronous code in JavaScript for beginners

JavaScript is single-threaded, which is to say it can only process one task a time. To handle shortcomings of this approach, it has an event queue that allows for asynchronous code to be executed in the appropriate order. In plain English, this means that JavaScript allows for _promises_: it _promises_ to get a value back to you, when that value becomes available. 

# Comparing .then vs. async/await


## Asynchronous with .then

```javascript
create(req, res) {
  const { title, entries = [] } = req.body;
  let createdList = {};
  let createdEntries = [];

  return List
    .create({ title })
    .then(list => {
      createdList = list;
      const listId = createdList.dataValues.id;
      if (!(entries && entries.length)) return Promise.resolve([]);
      const entriesToInsert = entries.map((entry) => ({
        ...entry,
        list_id: listId
      }));
      return Entry.bulkCreate(entriesToInsert);
    })
    .then((newEntries) => {
      createdEntries = newEntries;
      return res.status(201).send({
        list: createdList,
        entries: createdEntries,
      });
    })
    .catch(error => {
      return res.status(400).send(error);
    });
}
```

## Asynchronous with async/await

There's a lot to like about the async/await pattern. It reads more like synchronous code, which is to say it reads better than the .then pattern. It also has fewer scoping considerations, which makes it much easier to make variables available throughout the method. 

For those unfamiliar with the `await` keyword, it will 'pause' code until the promise proceeding it is resolved, then it returns the resulting value. 


```javascript
const create = async (req, res) => {
  try {
    const { title, entries = [] } = req.body;
    let createdList = {};
    let createdEntries = [];

    createdList = await List.create({ title });
    let listId = createdList.dataValues.id;

    if (entries.length) {
      const entriesToInsert = entries.map(entry => ({
        ...entry,
        list_id: listId
      }));
      createdEntries = await Entry.bulkCreate(entriesToInsert);
    }

    res.status(201).send({
      list: createdList,
      entries: createdEntries
    });
  } catch (error) {
    res.status(400).send(error);
  }
};
```

# Closing

Which snippet did you prefer? Which was easier to read? While a lot of talk of optimization refers to time and space complexities, there's a lot to be said for optimizing _readability_, which is why I prefer the async/await pattern.
Releasing package/library into production?
Tags: discuss, php, python, ruby
Published: 2020-03-13 11:12:27

---
title: Releasing package/library into production?
published: true
description:
tags: discussion,PHP,Python,Ruby
---

Whenever you finish writing a new package/library/bundle in any language what you do next until you put it in action either for the open-source community or your company apps?!

I mean once you finish writing it what do you do next, how do you do the testing, do you put it in an actual project or a clean project to test it and see it in action how it works or you just rely on the unit tests you write for it or what exactly?
Destructuring Array in javascript
Tags: javascript, reat
Published: 2020-03-13 11:07:56

Destructuring arrays and destructuring objects are similar. We use square brackets ([]) instead of curly brackets ({}).

```javascript
let [one, two] = [1, 2, 3, 4, 5]
console.log(one) // 1
console.log(two) // 2
```

while destructure an array, your first object belongs to 1st item from the array, the second object belongs to 2nd object from the array, so on and so far.

```javascript
let scores = ['98', '95', '93', '90', '87', '85']
let [first, second, third, ...rest] = scores

console.log(first) // 98
console.log(second) // 95
console.log(third) // 93
console.log(rest) // [90, 87, 85]
```

if you want to get only a few items from the first indexes and used the rest of them in the same manner, so here comes the Rest Operator in usage like above.

Thankyou.