teleren/devto huggingface dataset:
You are not worse when you are rejected
Tags: career, interview, growth, advice
Published: 2019-07-14 22:53:59

Tomorrow I'm starting a new job as a Software Development Engineer at Amazon. It's a step in my career that I would have considered completely unbelivable a few years ago, and maybe even a few months ago.

Since I got the offer, I've been thinking a lot about how I got to that point. Of course, a very important part about it is preparing for the interview adequately, but there are hundreds of articles talking about the Amazon interview process, or about how to pass interviews at Big 4 or other great software companies; probably I will write one myself in the future, because I think that it may be useful to someone in the same way that the articles of people that interviewed with them before were useful to me. However, there's another part of the process that it's not often mentioned, and that really made a difference in my case: simply, being lucky.

It's not a mystery to anyone that has been looking for a job that in most of the positions you apply to you won't get an answer, or if you do it will be to let you know that you have been rejected. That happened to me too: I also tried applying to lots of other companies, like Shopify, Stripe or Airbnb; and in all of them, I got rejected before even getting to the interview process.

At first, all those rejections made me reconsider if I should even keep trying: if all those companies were rejecting me before even interviewing me, maybe I wasn't good as a software engineer. Maybe my experience wasn't enough, or maybe it was the lack of open source contributions. However, in the end I was contacted by Amazon, I entered the interview process, and ended up receiving a good offer from them. I tried to analyze what I did differently to reach further in the process, but the problem was that I couldn't compare that situation to the others, because on those I didn't even had the chance to prove my skills.

Then it's when I realized one of the most valuable lessons I've learned in this interview process: the "me" that got rejected from lots of companies is the same "me" that got an offer from Amazon. My experience was the same, my skills were the same, my potential was the same. The only difference between those two days, is that one I was more lucky than the other: maybe that version of my CV highlighted exactly something that they where looking for or maybe it's simply that Linkedin search results showed me on the second page instead of the tenth. I'm not sure what may have been the root cause, but the consequence was that it allowed me to get to the interview process, where the outcome depended only on myself.

Getting rejected is hard, because we tend to think that we've done something wrong and that there's something about ourselves that we should change. But it's important to realize that sometimes the reason for being rejected was completely out of our control, and that what we have to do is not to get discouraged and stop, but to keep trying until you get a chance to actually show what you're worth.
{A} Numbers - All things are number
Tags: dataprocessing, json, startup
Published: 2019-07-14 22:42:15

![](https://thepracticaldev.s3.amazonaws.com/i/i9snq0cikusfynda5oba.png)

Today I want to show you something I've been working on lately, and ask for any feedback and ideas about the next steps :)

Lets imagine... Every piece of data can be converted into static {A} Number.



## Pack Your Data

Process and store any type of textual information: Articles, white papers, books, code backups, json, html markup, css, code snippets, databases or any other.

## Get Short Number And Instant Access Link

Get A digital representation of your data and a short access link to your information. Use it everywhere: online and offline. You can share your data with anyone or just keep it for yourself with a private password. Private data can be viewed or updated only if you pass a valid password-key.

## Unpack Your Data

Just use your number for back data conversion. Every {A} Number represent a piece of information.

## Organize And Manage Your Data

Get a personalized dashboard on signing up. Edit, organize your Public or Private A records. Use Collections feature to store your data in an organized way.

## Extensive API

Get all the details on how to CREATE, READ, UPDATE Or DELETE your data, create Private or Public data on 100A.IO with our extensive API Reference.

## Applications

Use Any of our predefined high quality apps to generate beautiful representations of your data.

Visit us: [100A.IO](https://100a.io)
The Cake Mix Metaphor for Frameworks
Tags: hibernate, java, rant, noframeworks
Published: 2019-07-14 21:48:14

---
title: The Cake Mix Metaphor for Frameworks
published: true
cover_image: https://thepracticaldev.s3.amazonaws.com/i/t3tgifo8znhrzo9cpicg.jpg
description: "Hibernate should be to programmers what cake mixes are to bakers: beneath their dignity."
tags: 
  - hibernate
  - java
  - rant
  - noframeworks
---

A great video was brought to my attention on Twitter recently. It's a lightning talk by [@CristinGorman](https://twitter.com/ChristinGorman) that she gave at JavaZone in 2011.

The title is

## Hibernate should be to programmers what cake mixes are to bakers: beneath their dignity.

which is pretty punchy.

Hibernate, for those of you lucky enough to never have used it, is a 'library' for interacting with relational databases in Java. 

{% vimeo 28885655 %}

It reminded me of my own rant

{% link gypsydave5/why-you-shouldnt-use-a-web-framework-3g24 %}

And I wish I'd seen it a long time ago. The cake mix metaphor is outstanding - it expresses exactly what I've been trying to say about frameworks. But better, because it's baking.

Something to chew on...

---

Image credit: [_The Gathering of the Manna_](https://commons.wikimedia.org/wiki/Category:Master_of_the_Gathering_of_the_Manna), by The Master of The Gathering of the Manna.

If you're ever feeling under appreciated, consider that even those of us who can produce artworks that last over five centuries have become [anonymous](https://commons.wikimedia.org/wiki/Category:Master_of_the_Gathering_of_the_Manna)...
Getting your hobby project of the ground
Tags: typescript, javascript, html, gamedev
Published: 2019-07-14 13:34:21

---
title: Getting your hobby project of the ground
published: true
description: How I started working on a hobby project I really wanted to do
tags: typescript, javascript, HTML5, game development
---

I have been a professional developer for nearly two years now but don't see much difference in my coding abilities. 

Yes, I have become more fearless in facing a screen scribbled with errors and can work my way through it and have picked up some technologies along the way (React, Node, Java) and learned the way of the terminal :D 

But something is still missing I don't have any open source contributions and my Github profile looks pretty boring. Several abandoned projects :( and this obviously affects my first impression on potential employers.

So, I have decided that I am going to finish my first hobby project which is a game built using canvas and typescript(the minimum viable product, as I am planning to add multiplayer action!).

And so far I have managed to set up the project from scratch and created the basic architecture. I am using Typescript, Webpack, and native canvas API to achieve the MVP along with Eslint and Prettier for smooth development experience.

The repo and corresponding GitHub project can be found at https://github.com/KartikJha/color-sticks.

I have set up the project without any boilerplate by scrounging the internet but will be happy to write a consolidated article you need it.

Thanks for reading this far. I will make sure that this hobby project gets delivered. 

What are you working on or planning to work on? Let me know in the comments.
How to check a mandatory variable in a Makefile
Tags: tooltip, makefile
Published: 2019-07-14 21:13:55

---
title: How to check a mandatory variable in a Makefile
published: true
description: Guard a variable in a Makefile
tags: tooltip, makefile
series: Makefile tooltip
---

When you use a variable in a Makefile task and you want to make it mandatory and check it before run the effective task,

You can `guard` it.

```Makefile
task-who-need-SPECIFIC_ENVVAR: guard-SPECIFIC_ENVVAR
	@echo ${SPECIFIC_ENVVAR}
```

You only need to add the following task

```Makefile
guard-%:
	@ if [ "${${*}}" = "" ]; then \
		echo "Environment variable $* not set"; \
		exit 1; \
	fi
```

So when you run it, the `guard` will prevent to run the task

```shell
$ make task-who-need-SPECIFIC_ENVVAR
Environment variable SPECIFIC_ENVVAR not set
make: *** [guard-SPECIFIC_ENVVAR] Error 1
```

```shell
$ export SPECIFIC_ENVVAR=value
$ make task-who-need-SPECIFIC_ENVVAR
value
```

See https://stackoverflow.com/a/7367903/1848685
Do you use GUI for git on Linux? Which one?
Tags: linux, git, gui
Published: 2019-07-14 20:01:40

---
title: Do you use GUI for git on Linux? Which one?
published: true
tags: linux, git, gui
---
**Hello everyone!**

I want to ask you which GUI you are using on your machine with Linux or do you use CLI? 

I'm asking because i'm not sure which one to choose. I have been using Git Extensions on Windows and i fell in love with it, because it's completely free and has awesome features and decent UI. 

However support for Linux is quite poor and it's not working properly (or i just can't configure it properly) 

So what are your favorites? 

[UPDATE]:
If anyone is running on Linux and has hard times finding a fitting git GUI, i can recommend [gitahead](https://gitahead.github.io/gitahead.com/), which is open sourced and has all things i needed:
- Graphical git history
- Simple straightforward UI
- Playing nice with custom OS themes
What makes you choose the language you write your articles in?
Tags: discuss, languages, blogging
Published: 2019-07-14 15:54:18

---
title: What makes you choose the language you write your articles in?
published: true
description: You may be fluent in several languages, so how do you choose?
tags: discuss, languages, blogging
---


## Making a choice?

This discussion is obviously aimed at people who are able to speak more than one language. I am French ( therefore I am fluent in that language ), and I'm fluent enough in english. 

I can write my articles in two different languages. 3 choices possibles:

- Write in french
- Write in english
- Write in french and english

Right now, I'm writing exclusively in english. I've learn to code with English resources, and it felt like a more natural way to write about what I was learning. 

## What are your goals?

Like most, I write to achieve certain goals. Increase my online visibility and retain the informations I'm learning are the main ones. I've always felt like writing in English was the *best* language ( between the two I know ) to achieve these goals. 

## What about the platforms?

Choosing the english language depended also on the dev.to platform. This is where most of my views came from, and writing in french here would decrease the number of people who could read my articles. I'm personally thinking about writing/publishing in french on my personal blog and keeping english for *international* platforms like dev.to.


Writing every article in both english and french do seem like it would be quite time consuming, and I'm not sure I could keep this up for very long.

So, I'm curious about what you people choose when you decide to write an article.

Can't wait to read your experiences :heart:
Debugging @track and @api properties in Lightning Web Components(LWC) using Chrome Dev Tools Formatter
Tags: lightningwebcomponents, lwc, salesforce
Published: 2019-07-14 18:31:00

Lightning Web Components (LWC) `@api` and `@track` decorators make component rendering a breeze, but they can be tricky to debug. The reason they can be tricky is because they are implemented using [ES6 Proxies](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy). Proxies allow LWC to transparently know what properties are being rendered in your template but they are tricky to inspect in the Chrome Dev Tools. The best approach to debugging `@api` and `@track` properties is to enable the [custom dev formatter](https://docs.google.com/document/d/1FTascZXT9cxfetuPRT2eXPQKXui4nWFivUnS_335T3U/preview#!) that comes out of the box with LWC.

## Inspecting with Dev Formatter Disabled

For example, [let's say we have a simple component that contains a single _@track_ property](https://developer.salesforce.com/docs/component-library/tools/playground/7HPESVkxh/1/edit):

```javascript
import { LightningElement, track } from 'lwc';

export default class App extends LightningElement {
    @track property = { value: 'Hello World' }
}

```

When we inspect `property`, Chrome will include all kinds of information about the _proxy_ that is used to implement `@track`:

![Inspecting tracked property without dev tools formatter](https://thepracticaldev.s3.amazonaws.com/i/ohzywn6j87gqb7d5j3ca.png)

## Inspecting with Dev Formatter Enabled

After we enable the custom dev formatter, our debugging experience becomes much better:

![Inspecting tracked property with dev tools formatter](https://thepracticaldev.s3.amazonaws.com/i/ptu6h3f5negjjxjsqyfa.png)

## Enabling Custom Dev Formatter


Enabling the custom dev formatter is easy:

<table>
  <tr>
    <td>
      1) Open the Web Inspector <br />
      2) Open the Web Inspector Settings
    </td>
    <td>
     <img src="https://thepracticaldev.s3.amazonaws.com/i/30nj00k7wyhtkan59mdm.png" alt="Open Web Inspector Settings" />
    </td>
  </tr>
  <tr>
    <td>
      3) Scroll down to "Console" section and check "Enable Custom Formatters" 
    </td>
    <td>
      <img src="https://thepracticaldev.s3.amazonaws.com/i/rgpg55z6ppb5rvbrvw5l.png" alt="Scroll down to 'Console' section and check 'Enable Custom Formatters'" />
    </td>
  </tr>
</table>

Happy Coding!
TPP Topic 6: Your Knowledge Portfolio
Tags: thepragmaticprogrammer, book, programming, education
Published: 2019-07-14 18:16:05

---
categories:
- The Pragmatic Programmer
published: true
tags:
- The Pragmatic Programmer
- book
- programming
- education
title: 'TPP Topic 6: Your Knowledge Portfolio'
---

> This post originally appeared on [steadbytes.com](https://steadbytes.com/blog/the-pragmatic-programmer-20th/topic-6-challenges/)

<div></div>

> See the [first post](https://dev.to/steadbytes/the-pragmatic-programmer-20th-anniversary-edition-series-1e2l) in The Pragmatic Programmer 20th Anniversary Edition series for an introduction.

## Challenge 1

> Start learning a new language this week. Always programmed in the same old language? Try Clojure, Elixir, Elm, F#, Go, Haskell, Python, R, ReasonML, Ruby, Rust, Scala, Swift, TypeScript, or anything else that appeals and/or looks as if you might like it.

Not long after reading this chapter for the first time, I started learning [Clojure](https://clojure.org/) using Daniel Higginbothams excellent book [Clojure for the Brave and True](https://www.braveclojure.com/). I have some past experience with functional Lisps (Scheme and Racket) and have _dabbled_ with Haskell however Clojure caught my attention due to bringing the power of the JVM to a well designed, functional Lisp as well as its first class support for Concurrency. Feel free to take a look at my progress through Clojure for the Brave and True on [GitHub](https://github.com/SteadBytes/clojure-for-the-brave-and-true)!

## Challenge 2

> Start reading a new book (but finish this one first!). If you are doing very detailed implementation and coding, read a book on design and architecture. If you are doing high-level design, read a book on coding techniques.

Recently at work I have been part of several new projects, all of which have been complex, distributed systems which must fit in to (or at least communicate with) an existing system. In an attempt to keep complexity of these systems to a minimum, I read through [A Philosophy of Software Design](https://www.amazon.co.uk/dp/B07N1XLQ7D/ref=dp-kindle-redirect?_encoding=UTF8&btkr=1) by John Ousterhout. A short, but excellent and well written book that addresses:

> The fundamental problem in software design, which is managing complexity.

I may do a more detailed book review, but I was able to utilise much of the learning in these new systems. To highlight a few:

- Modules should be deep
- Define errors out of existence
- **Design it twice**
  - Emphasis due to how useful this is
- Consistency

## Challenge 3

> Get out and talk technology with people who aren’t involved in your current project, or who don’t work for the same company. Network in your company cafeteria, or maybe seek out fellow enthusiasts at a local meetup.

Tying in nicely with [Challenge 1](#challenge-1), I recently attended [London Clojurians](https://www.meetup.com/London-Clojurians/) Clojure Dojo meetup in London. The meetup is extremely welcoming to anyone of any ability (I had done all of about two hours of Clojure) and was a great way to get stuck in and learn from others.
Backend App is Done, Published using single instance of VM, A Guide to Scale?
Tags: discuss, scalability, devops, intro
Published: 2019-07-14 18:05:59

So here's the thing. There is a backend application that contained REST API service. It was already deployed in a VM instance. 

# Horizontal Scaling
In order to enable the backend app to serve more connections, **is load balancing** (instantiate new instances and config NGiNX) **the only thing possible**?

# Vertical Scaling
Alternative way to enable the backend app to serve more connections, **is upgrading the instance spec the only thing possible**?

# Other Scaling
Is there something other than horizontal or vertical scaling in order to enable this backend app to serve more connections? 

Something like refactor code to be more efficient by **add or change something in the code**?

### P.S.
I appreciate any kind of thoughts about this topic.
4 tech terms in programming that you might not know
Tags: webdev
Published: 2019-07-14 17:15:12

### a11y 

refers to ally as a word that symbols web accessibility or accessibility in general.



### i18n

refers to internationalization which means  the translation of  an app in several languages.



### L10n 

refers to localization which it's main goal is to adapt the app to meet the linguistic & cultural requirements, date format, etc..



### g11n

refers to globalization or glocalization **a combination of globalization & localization** which is a term that combines the use of internationalization and localization.
Why (! + [] + [] + ![]).length is 9
Tags: javascript, todayilearned
Published: 2019-07-14 17:11:23

Edit: At the bottom I've added what I've figured out since I wrote this.

Today I sat down and figured out why you get this result in JavaScript
```javascript
(! + [] + [] + ![]).length
> 9
```

So I sat down with the js console and tried to figure things out. There were a lot of this going on:

```javascript
(!"")
>true

(![])
>false

(!+[])
>true

(!+[]+[])
>"true"

(+[]+"2")
>"02"

([]+"2")
>"2"
```
What I have come up with, and I might be totally off on some of these so please correct anything that doesn't look right, is the following.

* JavaScript does operations from right to left.
* The + operand first tries to add the left to the right, if that isn't possible it tries to convert the operand on the right to a number and if it can't  do that it converts it to a string.
If there is something to the left of the + it adds them together, and if it can't it sticks around. If there is nothing to the left it goes away.
* The ! operand converts the operand to the right to a boolean and then reverts it.
Only the following values are the same as false as booleans:
```javascript
false
0
""
null
NaN
undefined
```
All other values is not false and thus true.

So now it goes something like this:
```javascript
// We start with
(! + [] + [] + ![]).length  // Remember that we are going from right to left starting 
                            // with the operation before doing -length
![] === false               // ! converts the content of [] to true, since it's not part of 
                            // the false group above, and then reverts it.
+ === +                     // the + is lonely so far with no operand to the right but sticks 
                            // around since it has something on the left.
[]+[] === ""                // The contents of [] can't be added or converted to a number so 
                            // the right operand becomes a string. There's still something to 
                            // the left so the + stays.
!+[] === true               // This the same as !+0 since +[] is 0


// Now we got: 
("false" + "" + false).length
""+false === "false"        // + adds "" to false. It then sticks around.
"true" + "" === "true"      // The + stays after adding "true" to ""


// ---
("true"++"false") 
+"false" ==== "false"       // + has nothing but an operand to the left so it goes away.
true + "" === "true"        // + adds them together and stays

// ---
("true"+"false")
"true" + "false" === "truefalse" // + still stays

// ---
(+"truefalse")
+"truefalse" === "truefalse"     // + has nothing to do after this so it goes away

// ---
("truefalse")               // The operation is done so now we are left with what's outside.

"truefalse".length === 9

```

Yes, I did go through every step, even those that seems pointless. I'm not at all sure this is how it works but it is what seems to happen to me.

Thoughts?

Edit:
After comments and looking at the documentation this is now how I figure things going.
((!(+[]))+[]+(![]))
Unary operators are going right to left thus !+[] becomes +[] -> !0 === true.
5  Rails Migration Patterns to Save the Day
Tags: rails, migrations, generate, beginners
Published: 2019-07-14 17:00:23

Apologies in advance because the formatting for this post is a little funky. The original goal was to have a numbered list, but that's not working out.

However, each migration builds on the previous so I hope it helps you understand the flow of setting up Rails migrations.

Create a new model Users
- rails g model Users :name :city
```ruby
class CreateUsers < ActiveRecord::Migration[5.2]
  def change
    create_table :users do |t|
      t.string :name
      t.string :city

      t.timestamps
    end
  end
end
```

Rename your Users Table to Accounts
- rails g migration rename_users_to_accounts
```ruby
class RenameAccountsToTwitterAccounts < ActiveRecord::Migration[5.2]
  def change
    rename_table :users, :accounts
  end
end

```

Add a new column to your Accounts table
- rails g migration AddEmailToAccounts email:string
```ruby
class ChangeAccountsTable < ActiveRecord::Migration[5.0]
  def change
    add_column :accounts, :email, :string
  end
end
```

Delete the Accounts table from your database
- rails g migration DropInstalls
```ruby
class DropAccounts < ActiveRecord::Migration[5.2]
  def change
    drop_table :accounts
  end
end
```
Undo your recent changes
- rails db:rollback
Devlog: STIM (Simple Tiny Interactive fiction Maker)
Tags: devlog, interactivefiction, javascript, gamedev
Published: 2019-07-14 23:03:10

---
title: Devlog: STIM (Simple Tiny Interactive fiction Maker)
published: true
tags: devlog, interactivefiction, javascript, gamedev
canonical_url: https://triptych.writeas.com/devblog-stim-simple-tiny-interactive-fiction-maker?pk_campaign=rss-feed
---

Devlog: STIM (Simple Tiny Interactive fiction Maker)

I was thinking about minimalist app making – where you just put together the most basic version of an app, and it struck me how I often try to over complicate things ( for example the HTML version of IttyBittyRPG ) so I set a goal for myself to create just a super minimalist Interactive Fiction tool I'm calling STIM. I'm using Repl.it to code it, Cash and Torus for the JS, and Bulma for the CSS ( and Font Awesome – which is ... Awesome!)

If you want to follow along you can check out this project:

<iframe src="https://repl.it/@triptych/Super-Tiny-IF-Maker-STIM?lite=true" allowfullscreen="true" style="width:100%; height:800px;"></iframe>

{% replit @triptych/Super-Tiny-IF-Maker-STIM %}