teleren/devto huggingface dataset:
Show off your Test Automation Skills!
Tags: testing, automation, career, discuss
Published: 2019-03-20 09:09:53

---
title: Show off your Test Automation Skills!
published: true
description: Test Automation University introduces certificates
tags: Testing, Automation, Career, Discuss
cover_image: https://thepracticaldev.s3.amazonaws.com/i/vf7gtlr5jlmwkmth9q2s.jpg
---

I recently posted about the Test Automation University:

{% link https://dev.to/dowenb/path-to-test-automation-success-587p %}

They have just introduced a shiny new feature, where you get a "Certificate" for completing a course, that can easily be shared on Twitter, LinkedIn or put on your CV!

They have also introduced a few new courses since my last post, including:
- [Introduction to TestNG](https://testautomationu.applitools.com/introduction-to-testng/) with Rex Jones II
- [Automating your API tests with REST Assured](https://testautomationu.applitools.com/automating-your-api-tests-with-rest-assured/) with Bas Dijkstra

If you have already completed a course, you can 
[find your certificate here](https://testautomationu.applitools.com/certificate).

For example, here is one of mine:
![Ben's Certificate](https://thepracticaldev.s3.amazonaws.com/i/btbi6hjkryb13n5opyvq.png)

Got any other, creative ways, to show off your learning and skills? Maybe you have a great technique for building a portfolio, or you do all your learning in open GitHub repos so you can show perspective employers?

Let me know! I'm looking for new ways to record and show off my learning - while also opening myself up so others can more easily critique my work and give me feedback. Discuss in comments.
Renovate meets Bitbucket Pipelines
Tags: renovate, bitbucket
Published: 2019-03-20 08:55:49

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

## Renovate

[Renovate](https://github.com/renovatebot/renovate) is an open source tool for keeping dependencies up to date automatically via pull requests. It is an alternative to [Greenkeeper](https://greenkeeper.io/) that only works with [GitHub](https://github.com/).

## Bitbucket Pipelines

[Bitbucket Pipelines](https://bitbucket.org/product/features/pipelines) brings continuous integration and delivery to [Bitbucket Cloud](https://bitbucket.org/product), empowering teams to build, test, and deploy their code within Bitbucket.

## But how does Renovate work with Bitbucket Pipelines?

The first thing we need is a new repository with a `package.json`:

```javascript
{
  "name": "renovate",
  "version": "1.0.0",
  "description": "Multi-language dependency update automation",
  "private": true,
  "scripts": {
    "start": "renovate"
  },
  "devDependencies": {
    "renovate": "^14.50.3"
  }
}
```


### Authentication

It is recommended to create a separate Bitbucket user (e.g. `renovate-bot`) for Renovate.
After that [create an app password](https://confluence.atlassian.com/bitbucket/app-passwords-828781300.html) and store it in the `RENOVATE_PASSWORD` [environment variable](https://confluence.atlassian.com/bitbucket/variables-in-pipelines-794502608.html).

### Pipeline

In the root directory create the file `bitbucket-pipelines.yml` with the following content:

```yaml
image: atlassian/default-image:2

pipelines:
  custom:
    renovate:
      - step:
        caches:
          - node
        script:
          - git config --global user.email "bot@renovateapp.com"
          - git config --global user.name "Renovate Bot"
          - npm install
          - npm start
```

Use the `atlassian/default-image:2` image because it comes with Node.js and Git by default.


### Configuration

Renovate needs a [configuration](https://renovatebot.com/docs/self-hosted-configuration/). Create this in the root directory. An example `config.js` looks like this:

```javascript
module.exports = {
  platform: 'bitbucket',
  gitAuthor: 'Renovate Bot <bot@renovateapp.com>',
  username: 'renovate-bot',
  onboarding: true,
  onboardingConfig: {
    extends: ['config:base']
  },
  repositories: [
    'YOUR_USERNAME/YOUR_REPOSITORY',
    'YOUR_USERNAME/YOUR_REPOSITORY',
    'YOUR_USERNAME/YOUR_REPOSITORY'
  ]
}
```

Very important are the `platform` and `username` keys. The value of the `username` is the new user from step 1.


### Test Run

Now you can [manually trigger the pipeline](https://confluence.atlassian.com/bitbucket/run-pipelines-manually-861242583.html) from Bitbucket Cloud.


An initial pull request is now created in the specified repositories.


### Scheduled Pipelines

With the [scheduled pipelines](https://confluence.atlassian.com/bitbucket/scheduled-pipelines-933078702.html) feature you can run the pipeline automatically at certain times.
Three ways to solve a problem
Tags: beginners, career, meta, programming
Published: 2019-03-20 08:54:41

---
title: Three ways to solve a problem
published: true
description: 
tags: beginners, career, meta, programming
canonical_url: http://jesperreiche.com/three-ways-to-solve-a-problem/
---

In software development and perhaps more broadly, in creative endeavors in general, rarely does one solve a problem that has only one possible solution. Mostly there are *“more ways than one to skin a cat”*.

There is the “wrong way” which causes more problems than it really solves. This is usually where the newcomer goes wrong. Lacking experience with both the environment and tools, the inexperienced is fighting an uphill battle understanding both the problem and the consequences of a proposed solution. The fun part is that in an environment with good testing and feedback, this can actually be one of the *quickest* way to get problems solved. 

Fail fast.

Then there is the striving for the unobtainable “perfect solution” to a problem. This is usually the “lightly trained” or “slightly experienced” Achilles heel. Having spent enough time in the trade to see that there are “bad” solutions, the pursuit now goes for the perfect “good” solution. This leads to analysis-paralysis and in software development usually over engineering. This will usually be the slowest and the most *expensive* solution/way to solve a problem.

The third way is the “least bad” solution. This is where experience makes it mark. Having enough experience to identify “really bad” solutions, **but** also the confidence and full overview of the problem, to not chase a non-obtainable perfect solution.

The sweet spot is usually the “least wrong” solution.

The one which solves the problem in a good way while not closing too many doors, but on the other hand not trying to keep all thinkable doors open (over engineering). This is of course in no way an easy feat. Trying to find the “least wrong” solution can be as exposed for over engineering and analysis paralysis as the “perfect solution”.

Even more annoying is the fact that you will probably only really be able to see a clear difference over time. But hopefully over time and with experience you will also be able to recognize where you created a solution that fits either of the three above scenarios and hence progress towards “less wrong” solutions.
What are you doing currently?
Tags: discuss
Published: 2019-03-20 07:33:47

---
title: What are you doing currently?
published: true
description: software engineering books
tags: discuss
cover_image: https://thepracticaldev.s3.amazonaws.com/i/tdltk7o7gvtrvbn991z5.jpg
---

I am busy in copying and pasting from StackOverflow

![Alt text of image](https://thepracticaldev.s3.amazonaws.com/i/tdltk7o7gvtrvbn991z5.jpg)
How to find inspiration for a side-project
Tags: sideprojects, ideas, tips, learning
Published: 2019-03-20 07:05:14

---
title: How to find inspiration for a side-project
published: true
description: A couple of tips on how to find side-projects that you can put your teeth (and code) in
tags: side-project, ideas, tips, learning
cover_image: https://thepracticaldev.s3.amazonaws.com/i/hqrtgn5m5gmfyi83ey0m.jpg
---

1. The generally accepted best (AND most talked about) way to find a suitable side-project is to think about digital annoyances that you have in life, and how you would fix them. Scratching your own itch is called out as one of the best ways to find a side-project. It helps you to solve something that you experience yourself so it makes you kind of an expert since you have expectations that are not met. Those expectations might lead to a product/service.
**PRO-tip:**
Start by writing down things that you notice. I have a Trello board full of all my ideas. I organize them into columns Mind spins > Investigating > Serious > Executing > Done > Archive > Trashbin. I regularly go over the board and investigate the most interesting (most chance of being viable and least amount of work/fastest shipping possibility) and groom the board. Since I wrote down all my ideas I have enough to work on. 

2. Talk to people; talk about stuff that's bothering them. Don't fall into the steep canyon of talking solutions. Go way back to the origin of the problem that they're experiencing, and think along from that. 5 Why's are also great here: ask them 5 times why to their answer to finding out the _real issue_.

3. Check out www.producthunt.com and [search for "side project ideas"](https://www.producthunt.com/search?q=side%20project%20ideas) to find inspiration and tools to help you pick a side-project

4. Buffer has some great advice in [this post on side-projects](https://open.buffer.com/getting-started-side-projects/) in which they talk about how they approach it and what projects they're currently up to. Check it out!

5. Google for [side-project ideas](https://www.google.com/searchq=side+project+ideas)
init commit
Published: 2019-03-20 06:31:26

Let's get this out of the way. This is my first post!

I wanted to make a blog for the longest time. I never took the time to complete one, even though I tried several times to start one, using static site generators on my own domain.

Yesterday night I read a post from @brunolemos on here, on my phone. It was a technical post like the ones I would like to make, and it looked great on my phone screen, so I made an account (and even put a small monthly donation, I'm a sucker for betas of all kinds 😁). Now it's the next morning, and I am making the first post to explain myself and in a few minutes I'll be typing my first actual post.

Look forward to that! Thank you and see you in the comments soon.
How to write in specific number of columns in excel file using xlwt?
Tags: pythonxlwtexcel
Published: 2019-03-20 05:21:56

---
title: How to write in specific number of columns in excel file using xlwt?
published: true
description: How to write in specific number of columns in excel file using xlwt?
tags: python xlwt excel
---

I have a list say

    po = ['Mon', '6421', 'Tue', '6412', 'Wed', '12416', 'Thu', '23483', 'Fri', '8978', 'Sat', '7657', 'Sun', '6555']

and I wish to write this in an excel file based on user provided no. of sets, for e.g. say if user says "2" sets then this list in the excel look like

    Mon	6421	Tue	6412
    Wed 12416 	Thu 23483
    Fri 8978 	Sat 7657
    Sun 6555

So effectively, the data is populated in 4 excel columns.


----------


Similarly, if the user say "3" sets, then the data look like

    Mon	6421	Tue	6412	Wed 12416
    Thu 23483 	Fri 8978 	Sat 7657
    Sun 6555

So effectively, the data is populated in 6 excel columns.


----------
I have tried something like this but I dont know what to write in place of `?` and `line#14`. Can you please help?

    1 import xlsxwriter
    2
    3 wb = xlsxwriter.Workbook('dem.xlsx')
    4 ws = wb.add_worksheet("New Sheet")
    5
    6 po = ['Mon', '6421', 'Tue', '6412', 'Wed', '12416', 'Thu', '23483', 'Fri', '8978', 'Sat', '7657', 'Sun', '6555']
    7 user_set = 4
    8
    9 num_row  = ((len(po)/user_set) / 2 ) + 1
    10
    11
    12 for row in range(0,num_row):
    13    for col in range(0,user_set):
    14    	ws.write_row(row, col, ? )
    15
    16 wb.close()
CSS properties for adjusting text underline offset and thickness are coming to Safari
Tags: webdev, css
Published: 2019-03-20 04:46:23

---
title: CSS properties for adjusting text underline offset and thickness are coming to Safari
published: true
description: 
tags: webdev, css
---

Text underlines added via the CSS `text-decoration: underline` declaration are not drawn uniformly by the different browser engines. The underlines differ in thickness and vertical position.

![A comparison of how the heading “Quaggy papaya juice” is underlined in Chrome, Firefox, and Safari](https://thepracticaldev.s3.amazonaws.com/i/er57ioliwktkhzeq73x2.png)

This may be part of the reason why some websites such as Smashing Magazine use a hack based on CSS backgrounds to draw more consistent link underlines across browsers. (I have copied this approach for Web Platform News.)

![The set of CSS properties used to draw text underlines on Smashing Magazine](https://thepracticaldev.s3.amazonaws.com/i/vfvkrrj3zfxs8kyoq77q.png)

The preview version of Safari (since [Technology Preview 70](https://webkit.org/blog/8496/release-notes-for-safari-technology-preview-70/)) supports two new CSS properties that enable authors to <mark>adjust the thickness and offset</mark> of text underlines. These properties are defined in the [CSS Text Decoration 4 module](https://drafts.csswg.org/css-text-decor-4/).

```css
h1 {
  text-decoration: underline;
  text-underline-offset: 0.1em;
  text-decoration-thickness: 0.1em;
}
```

Try out the demo here: https://output.jsbin.com/busaboz/quiet.

{% youtube jsPLEJ65K9Q %}
Vim: Dynamic Case Insensitive/Sensitive Search
Tags: vim, neovim, search, casesensitve
Published: 2019-03-20 03:07:08

---
title: Vim: Dynamic Case Insensitive/Sensitive Search
published: true
description: This post it about how to search words in Vim / Neovim to ignore case after beginning to search under the default settings, "noignorecase" and "nosmartcase". "\\c" / "\\C" are the magic words. "\\c" enables case insensitive search dynamically. "\\C" is the opposite, i.e. sensitive search.
tags: vim, neovim, search, case sensitve
series: Vim/Neovim Tips
---

Hi 🙂
This post is about a small tip to search words in [Vim](https://www.vim.org/) / [Neovim](https://neovim.io/).

I sometimes wanted to ignore case after beginning to search some words; It was not applied under the default settings, `noignorecase` and `nosmartcase` (at least, in the [OpenBSD](https://www.openbsd.org/) 6.4's package).

It was difficult for me to customize a config file, aka `~/.vimrc` / `~/.config/nvim/init.vim` then.
Moreover, I didn't like stopping the search to type `:set ignorecase` which may have to be reset afterwards every time I meet the case.
Additionally, my life would have been harder if I had been accustomed to restart the program with reading a custom config file with `-u` option as needed: `vim -u %config-file%` / `nvim -u %config-file%`.

I found the way after all:
`\c` / `\C` are the magic words 😊

**`\c`** enables case **insensitive** search dynamically:

```
/\c%keyword(s)%
```

**`\C`** is the opposite, i.e. **sensitive** search:

```
/\C%keyword(s)%
```

Remember these options are prior to the config settings.

![image](https://thepracticaldev.s3.amazonaws.com/i/3k8u2lthwexo6yaudqnh.png)

For example, under `noignorecase` and `nosmartcase` environment:

|  (Keyword)  | "coffeebreak" is | "CoffeeBreak" is | "COFFEEBREAK" is |
|:---------------:|:----------------:|:----------------:|:----------------:|
| `coffeebreak`   | hit | not hit \* | not hit \* |
| `CoffeeBreak`   | not hit | hit | not hit |
| `\ccoffeebreak` | hit | hit | hit |
| `\cCoffeeBreak` | hit | hit | hit |
| `\Ccoffeebreak` | hit | not hit | not hit |
| `\CCoffeeBreak` | not hit | hit | not hit |

\* Under `ignorecase` and `smartcase`, it's hit. (Thus, the combination of the settings may be useful when a custom config file is available.)

If you want to read about these options in the official document, type in Vim:

```
:help ignorecase
:help smartcase
```

The gate is open!

Thank you for your reading 😄
I wish your happy life with Vim.
Visitor Design Pattern [Behavioral]
Tags: blog, concepts, designpattern, designpatterns
Published: 2019-03-21 19:29:27

---
title: Visitor Design Pattern [Behavioral]
published: true
tags: blog,concepts,Design Pattern,Design Patterns
canonical_url: https://itscoderslife.wordpress.com/2019/03/20/visitor-design-pattern-behavioral/
---

The visitor allows adding common behavior to unrelated types. It should be used if we cannot or don’t want to change the source code of the given types.

- It separates the new behavior into a dedicated visitor. The visitor must visit each object and performs required operations on that object’s state.
- If a new functionality is required, you must only extend the visitor, or create a new visitor for that matter.
- This pattern is useful if you need to traverse collections of heterogeneous objects and perform related operations.
- The visitor works without subclassing.

> The visitor lets us add new common behavior to unrelated types without changing their implementation.

Example: Suppose we have added a set of unrelated products, Book, Computer, and Car into a shopping cart of an online store. They have different properties for retrieving their price; itemPrice for Book, unitPrice for Computer, and stickerPrice for Car. So at the time of price calculations we need to check the product type and accordingly call its prie property. This is problematic when the product type list grows.

The visitor patterns solves this problem by extracting the new behavior into a visitor type. The visitor has visit methods that can handle each and every type. So, I declare the Visitor protocol with a visit method for each of the type Book, Computer, and Car. This interface for each type is defined in concrete class of visitor class.

Each product accepts a visitor and then the product calls the visit method of the visitor. This method knows how to calculate price of the product of particular type. _Accepting a visitor and calling its visit method_ – this is called double dispatch.

**Double dispatch** :

The concrete visitor types need to operate on the subject state. To receive the right instance, the visitor pattern uses a technique called double dispatch. For double dispatch to work, each type has to define an accept visitor method.

The accept method takes a visitor instance as an input argument. Calling the accept method ensures that the current subject gets chosen. For each subject, I implement the accept visitor method.

Accept visitor calls the visitor’s visit method with self as argument. This calls the correct visitor subclass and ensures that the right operation gets executed. The process is called double dispatch because of calling the accept and the visit methods.

In simple words : The visitor should be used to add new behavior to unrelated types without the need of subclassing. No such pitfalls however the concrete visitor interface can grow if abstraction is not done right.
My first job in Tech!!
Tags: beginners, career
Published: 2019-03-20 00:59:23

---
title: My first job in Tech!!
published: true
description: 
tags: beginner, career
---
I am very happy to announce my very first job in the technology field. I will be working as an entry level PC technician, which is still in the field that I obtained my bachelor's degree in last summer. I'm very excited to be on my way out of the industrial prison that I felt stuck in for almost 5 years. I felt I needed to share with this great community, since you all have inspired me over the last few years as I've lurked and occasionally posted. Next month starts the new adventure!

Yes, this is not a dev job, but I knew I probably wouldn't get one right away. I specialized in application programming, but feel that I still need to build my skill set on my own for now. I'm going to keep coding in my spare time, and become an avid developer eventually. For now, I'm basking in the high that is a new career in a promising field. Who knows what opportunities will become of this new job!
Rubber themes for vim
Tags: showdev, vim
Published: 2019-03-20 00:49:41

---
title: Rubber themes for vim
published: true
description: 
tags: #showdev #vim
---


A collection of color schemes (just two for now) with minimal amount of highlighting for Vim.

## Inspiration

Inspired by the same principles of the [alabaster color scheme](https://github.com/tonsky/sublime-scheme-alabaster) for Sublime Text:

> - Doesn’t highlight standard language keywords (if, else, function, etc). They are usually the most obvious part of any program.

> - Highlights comments. Most schemes try to dim comments by using low-contrast greys. If the code is complex enough that it deserves an explanation then it’s that explanation then we should see and read it first. It would be a crime to hide it.

> - Doesn’t use font variations. It’s hard to scan code when it jumps between normal, bold and italics all the time. Also, not all fonts provide bold/italics variants.

> - Minimal amount of rules means you can consciously use them to look for the exact piece of information you need. You can remember easily all the rules, e.g. if you need to look for a string you know that you’re looking for a green token. And all the strings really pop out because there are not many other things highlighted.

> - Only highlight things that parser could identify reliably.  When it’s not reliable, your brain spends precious brain cycles to re-check everything it sees on the screen.

## How does it look like
### rubber

A port of [rubber-theme](https://github.com/apust/vscode-rubber-theme) for VSCode.

![preview rubber](https://raw.githubusercontent.com/VonHeikemen/rubber-themes.vim/master/assets/screenshot-rubber.png)

### rubber-owl
Same thing, but using the color palette from Sarah Drasner's [Night Owl](https://github.com/sdras/night-owl-vscode-theme/).

![preview rubber-owl](https://raw.githubusercontent.com/VonHeikemen/rubber-themes.vim/master/assets/screenshot-rubber-owl.png)

## Get it now

{% github https://github.com/VonHeikemen/rubber-themes.vim %}
Building a file sharing app with Node.js, Vue.js, Cloudinary, and MySQL: Part 1
Tags: node, vue, cloudinary, mysql
Published: 2019-03-20 00:18:08

---
title: Building a file sharing app with Node.js, Vue.js, Cloudinary, and MySQL: Part 1
published: true
description: Building a file sharing app with Node.js, Vue.js, Cloudinary, and MySQL: Part 1
tags: nodejs, vuejs, cloudinary, mysql
---

In this tutorial series, we will be creating a secure file sharing app with links that automatically expires using Node.js for the API, Vue.js for the frontend, Cloudinary to host our images and MySQL for storing the records.

In the upcoming series, we will be going from an idea to a fully functional secure file sharing application.