teleren/devto huggingface dataset:
4 Major Mistakes To Avoid While Hiring A Logo Designer 
Tags: hirelogodesigner, logodesigncompany, logodesignerinsg, logodesignsingapore
Published: 2018-08-30 05:48:47

---
title: 4 Major Mistakes To Avoid While Hiring A Logo Designer 
published: true
description: Here are 4 mistakes you should avoid when you hire a logo designer
tags: hire logo designer, logo design company, logo designer in sg, logo design Singapore,
---
A business is defined by the logo that represents it. Having a neat and appealing logo can reel in a huge audience. Irrespective of the quality of your services, the first impression is always given by your company logo. Companies like Facebook, McDonald’s etc., have a dominant logo that defines them majestically.
 
**Here are 4 mistakes you should avoid when you hire a logo designer:**

**1) Hiring Friends:** A common mistake people make while getting a logo designer, is giving the job to their friends or relatives in an attempt to get it done at an affordable or budget friendly. There will always be a difference between them and professional. A logo is of paramount importance, and getting it made in the proper place is necessary! Although giving the job to an acquaintance might seem tempting, it'll prove costly down the line.

**2) Going Overboard:** A logo should be crisp and relatable to your company. Predominantly, a logo either contains the name or the service provided. Don't hire a painter when what you need is branding. Designing a logo takes time, don't usher the process. Ensure the process happens at a healthy rate and give it the necessary time.

![Logo Designer in Singapore](https://thepracticaldev.s3.amazonaws.com/i/vcfy3vuuba09cwocnnm3.jpg)

**3) Improper Conveyance:** When you are assigning a design task, ensure you describe it down to the smallest detail. Designing is a very important process and your designer should know all the details your business represents and your brand needs. 

**4) Keep it Simple:** Companies like Nike, Adidas etc., have simple and crisp logos, yet they are hugely valuable and effective at their job. The idea of designing is to keep it minimal and to the point. When you're tasking your logo designer with a requirement, make sure the outcome is simple yet appealing.

When it comes to branding, make sure it is nothing short of stellar. Get it done by the [Best Logo Design Company in Singapore] (https://www.openwavecomp.com.sg/web_design.html) - Openwave! We will deliver an impeccable logo for your business, at an incredibly affordable rate! Call us today to know more.
Who is developing enterprise solution?
Tags: discuss, help, career
Published: 2018-08-30 04:16:40

---
title: Who is developing enterprise solution?
published: true
description: 
tags: #discuss #help #career 
---

I think I am building enterprise solution. 

Enterprise solution is a complicated system which embedded in enterprise and help enterpise to solve problem.

As it is complicated, the developer may face a lot of difficulties. 

Let share your problem you face. I think I could help other.

# My Difficulties

* Unclear Requirement 
* User think IT can do magic (We can do the magic)
* Tight Schedule
* No Leader but Boss only
* Poor Documentation
* Dirty Code / Technical Debt
* No Planning 

# Reference

* [What is Enterprise Application](https://dev.to/imben1109/what-is-enterprise-application-4jk)
* [How do you estimate time required for assigned task?
](https://dev.to/imben1109/how-do-you-estimate-time-required-for-assigned-task-57md)
Mold an amateur's API authentication approach
Tags: laravel, php, api, discuss
Published: 2018-08-30 03:55:38

---
title: Mold an amateur's API authentication approach
published: true
description: Find what's wrong
tags: Laravel, PHP, API, discuss
---
The process
<img src="https://thepracticaldev.s3.amazonaws.com/i/qxfhwii6yos8in3zwklf.jpg">

I know and I am familiar that we have oauth/oauth2 advancements in the API authentication area but I can't help but explore my own ideas on it.

I have this idea for API authentication. Simple and straight to the point. But I can't help but feel that I lack a few more scenarios to consider on designing this flow.

Glossary/Legend :
Token = unique combination of string
User = Registered entity in the project/app
Red boxes = Process that would induce a "SELECT" clause
Blue boxes = "UPDATE" clause
Green boxes = "INSERT" clause

So to start, the User makes a request to the API to create a token, the API then checks the token table if there are existing ones tagged to the user that are not yet expired, if a token exists, the expiration will be increased and returned to the user, if none a new token is created and returned.

After successfully securing a token, the user is now able to request for resources from the API.

Now for EVERY resource request the user makes to the API, the request would only need to include the token (aside from the parameters of the resource requested) and the can already determine which user sent the request, the API will then check the validity and expiration of said token in the database, if token is valid, return the resource, if not return a 401 http code.

Additional notes : Thinking about 3rd party logins, Some sort of access type can be attached to the token to determine the purpose of it, i.e. access via facebook, twitter etc

I believe in this logic but I wanna find out things that would make this a more better and industry-standardized approach so to speak.

Cheers!
Using Twitter as a development tool
Tags: ssrs, ssis, datawarehouse
Published: 2018-08-29 21:39:12

---
title: Using Twitter as a development tool
published: true
description: how I went from barely knowing c# to building my first data warehouse
tags: ssrs, ssis, datawarehouse
---

I was taking over from a consultant and realized that we had a lot of data that we were collecting, but weren't putting it to good use.  I also saw that we had a lot of manual processes that we could eliminate if we uses SSIS properly to grab data.

So I started teaching myself SSRS and SSIS and lo and behold, I had a mountain of data.  Now what??

I started my twitter account in 2011(https://twitter.com/SQLKohai) and after learning that #ssrshelp and #ssishelp tags in my tweets led me to some quick solutions I found myself 'talking' to many people who either had similar issues, or had found solutions to something along the lines of what I was looking for.

Fast forward 7 years, and I'm getting to meet some of them, I'm reading the textbooks that a bunch of them are writing, and I'm preparing to speak at a User Group event in January.

Give me a shout on Twitter and I'll introduce you to the 'SQL Family' sometime.  For me, finding a group of likeminded, open people, was really refreshing.
The Right Idea Becomes the Wrong Idea Over Time
Tags: webdev, javascript, career
Published: 2018-08-30 00:49:55

---
title: The Right Idea Becomes the Wrong Idea Over Time
published: true
description: People support older versions of IE because they made the choice and never revisited it. People hate JavaScript because they had some bad experiences and never let old scars heal.
tags: webdev, javascript, career
---

#### 2008: Don't build your server-side application with JavaScript. Are you f#@cking crazy?

***

#### 2018: Build your server-side application with JavaScript. It's probably one of the most practical choices you can make.

***

Regardless of whether or not you believe the 2018 statement, it's plausible at the very least. Yet I find myself observing people being overly caught up in past advice, even when the entire ecosystem has evolved around that specific advice.

JavaScript stands out to me in this regard. If I were you, I _would_ avoid all things 2008 JavaScript like the plague. But 2018 JavaScript is practically an entirely different language. The ecosystem remains a bit wild for my tastes, but it's no longer true that the language itself is unworkable.

{% youtube c1QcjsjjtRc %}

<figcaption>This is a time-travel joke built around Japan's industrial advances</figcaption>

Past scars get more attention than they need to. For some of us, we never want to see JavaScript again in our lives, but 2018 JavaScript is a sensible choice with wonderful tooling. Things aren't perfect but it's no longer mangled spaghetti as a default. We figured a lot of stuff out, we built entire new runtimes. We wrote a lot of new code.

JavaScript is the example here, but this applies in general. New software concepts keep old names. Old best practices rot without getting appropriately discarded. The case that really made me want to make this point was one particular result from the [State of the Web Survey](https://dev.to/devteam/state-of-the-web-data---call-for-analysis-2o75) we just wrapped up.

![](https://cl.ly/92d8209fb944/Image%202018-08-29%20at%208.28.04%20PM.png)

25 percent of teams still support IE 10 and under!! I'm all for browser support but this is about 0.5% of browser activity being supported by 25% of teams! This is absolutely bonkers to me. There are a lot of use cases that could mandate supporting these old browsers, but I am certain it is not 25% of cases.

People support older versions of IE because they made the choice and never revisited it. People hate JavaScript because they had some bad experiences and never let old scars heal.

You don't have to love JavaScript, I'm not a big JS person myself, but the old joke is dead.

![](https://i.redd.it/h7nt4keyd7oy.jpg)

_I think this is one of the all-time funnier jokes in our industry. If anything, I mourn the fact that we can't complain about JavaScript like we used to._
Building a stack-based virtual machine, part 2 - the stack
Tags: rust, language, theory, computerscience
Published: 2018-08-30 00:28:56

---
title: Building a stack-based virtual machine, part 2 - the stack
published: true
description: The second part in my exploration of stack based VMs and how they work
tags: rust, language, theory, computerscience
---

You'll note that in [part one](https://dev.to/jimsy/building-a-stack-based-virtual-machine-5gkd) there wasn't really any code.  Sorry about that.  Let's fix that now.

If you want to jump to the end the completed source code for stack-vm is [on Gitlab](https://gitlab.com/huia-lang/stack-vm).

The first thing we need to build a stack machine is a stack: a data structure that we can push and pop operands into/out of.  Because we're using Rust that means we're going to use a [Vector](https://doc.rust-lang.org/book/second-edition/ch08-01-vectors.html) and we need it to be [generic](https://doc.rust-lang.org/book/second-edition/ch10-01-syntax.html).

```rust
pub struct Stack<T>(Vec<T>)

impl<T> Stack<T> {
  pub fn new() -> Stack<T> {
    Stack(vec![])
  }

  pub fn is_empty(&self) -> bool {
    self.0.is_empty()
  }

  pub fn push(&mut self, value: T) {
    self.0.push(value);
  }

  pub fn pop(&mut self) -> T {
    self.0.pop().expect("Unable to pop from empty stack")
  }
}
```

This gives us a generic stack which can only be pushed and popped.  We also added `is_empty` to make testing a little easier.  Speaking of testing, here's the tests.  Note that in our tests we make this a `usize` stack to make it nice and easy to work with.

```rust
#[cfg(test)]
mod test {
  use super::*;

    #[test]
    fn new() {
        let stack: Stack<usize> = Stack::new();
        assert!(stack.is_empty());
    }

    #[test]
    fn push() {
        let mut stack: Stack<usize> = Stack::new();
        stack.push(13);
        assert!(!stack.is_empty());
    }

    #[test]
    fn pop() {
        let mut stack: Stack<usize> = Stack::new();
        stack.push(13);
        let value = stack.pop();
        assert_eq!(value, 13);
    }

    #[test]
    #[should_panic(expected = "empty stack")]
    fn empty_pop() {
        let mut stack: Stack<usize> = Stack::new();
        stack.pop();
    }

}
```

In the [next instalment](https://dev.to/jimsy/building-a-stack-based-virtual-machine-part-3---instructions-4b3a) we will figure out what an instruction is, how to build one and make a nice table to store them in.
How do you rate your (a programming language) skill on a scale of 1 to 10?
Tags: interview, javascript, reflection, discuss
Published: 2018-08-30 00:13:49

---
title: How do you rate your (a programming language) skill on a scale of 1 to 10?
published: true
description: can you rate your programming skills?
tags: interview, javaScript, reflection, discuss
---

**How do you rate your javaScript skill? Give a number form 1-10.**

Have you been asked this question in a screening interview or in-person interview?

For me, I don't really know how to answer this question. But I know that 9 or 10 might not be the best answer unless you know the language inside out. But I know that I have overcome some hurdles of becoming a better developer over the last few years. I find myself interested in learning how a library was built and building one myself, and digging deep into its code base.

How do you answer this question? Can you share your experience or your reflection of where you are?
What is the journey like for a person to become really good? For example, a creator of React, Redux, or Rails framework?
Git Staging Area: Explained Like I'm Five
Tags: git, beginners, explainlikeimfive
Published: 2018-08-29 21:08:24

---
title: Git Staging Area: Explained Like I'm Five
published: true
description: Imagine you have a box.  Do you throw everything in it?
tags: git, beginners, explainlikeimfive
---

Imagine a box. You can put stuff into the box. You can take stuff out of the box. This box is the staging area of Git. You can craft commits here. Committing is like sealing that box and sticking a label on it. The contents of that box are your changes. So, why not have the label mean something? You wouldn’t label a moving box with kitchen items as simply “stuff.”

![Staging Area](https://cdn-images-1.medium.com/max/800/1*diRLm1S5hkVoh5qeArND0Q.png)

As you make changes locally, Git can "see" them. However, figuratively speaking,  they're out of the box.  If you were to try and make a commit at this point, Git wouldn't have anything to commit.

Here's how to relate the box analogy to some basic Git operations.

### git config --global user.name "Jonathan Irvin"

You create a seal that you will use for each box.  It has your full name on it.  Not a username or a screen name.  That would be silly.  You laugh to yourself at the silliness.

### git config --global user.email "jonathan@notmyemail.com"

You add your email address to your seal.  Would be useful should someone need to contact you about the contents...or yell at you.  You know, business as usual.

### git init

You build your desk and keep an infinite supply of boxes underneath the surface to place work items in for storage.

### git add

The moment you perform an add command, you're adding to the box.  Yes, grab a box.  Any box.  Put something in it.  You've just done a `git add`.

### git stash

Pick up the box and put it on a shelf away from your desk.  Your desk is clean, but your items are still easily accessible.

### git stash apply

Take the box off of the shelf and empty the contents back on to your desk...neatly.  Hopefully, you don't have anything on your desk already or you might have some conflicts!

### git stash clear

Take your arm and swiftly swipe all of the shelf contents into the garbage chute.  Who needed all of those half-baked ideas anyway?

### git reset HEAD -- `<file>`

Take one item out of the box.

### git reset HEAD -- `<directory>`

Take several grouped items out of the box.

### git reset --hard HEAD

Pour gasoline on the box and light it on fire.  Your stuff is now ashes. Gone. Forever.

### git commit -m "message"

Tape the box shut.  Label it with "message" and put it in storage with other labeled boxes.

### git revert

Hold a mirror up to the sealed box.  Magically, another box is created that appears to be an exact clone, yet completely opposite.  You keep the two boxes apart for fear they would cancel each other out.  It is the anti-box.

### git status

You look at your desk and see items on your desk, in the box, or both.

---

Now anytime you look at a box, you can't unsee it.
My Journey through JavaScript: Flowcharting Pt. 1
Tags: beginners, javascript, flowchart
Published: 2018-08-29 20:21:36

---
cover_image: https://thepracticaldev.s3.amazonaws.com/i/aix4ru20qtkg8m8d2gqr.jpg
title: My Journey through JavaScript: Flowcharting Pt. 1
published: true
description: An overview of what I learn as I learn JavaScript
tags: #beginner #javascript #flowchart
<meta prefix="og: http://ogp.me/ns#" property="og:image" content="{link to image address}" />
---
My first blog post :)

I have found through leading some study groups in my bootcamp that I reinforce what I have learned by explaining it to others. So I have decided to start writing blog post as well to further build on my understanding. 

So here we go...

FLOWCHARTING:

When I first started flowcharting I HATED it! But it was a necessary evil at first and now it is something I do every time I start working through a problem. While there isn't necessarily a standard for flowcharting, what I understand is that the only standard is that loops/conditionals are labeled the same way across all flowcharts. Loops/conditionals are denoted by a diamond. Now that we have the boring stuff out of the way let's get to flowcharting!

Here is a very simple flow chart example (we will get into more difficult ones as we move further into this series). We want to take in 2 numbers from the user, add the numbers together and then render the result. 

Step 1: Start (start with start like we always start)
Step 2: We will need two listeners
Step 3: These two listeners will take in two numbers one will be stored as input1 and the second will be stored as input2. 
Step 4: We need an operator to handle the adding
Step 5: We need to render the result. 

Now lets look at this in an actual flowchart...

<img src="https://thepracticaldev.s3.amazonaws.com/i/zbp9b0cshh63slxypqzk.PNG" />

In step 1 we added our start bubble so we know where our program starts. (In between step 1 and step 2 I went ahead and added an empty variable for my result so I can keep track of variables that I will need later on in the flowchart. You can also define this variable in step 4). In step 2 we added two listeners which indicate we need our program to ask the user for information. In step 3 we take the user information and store it in variables called input1 and input 2. Now that we have our user information we can move to step 4. In step 4 we use the variable result that was previously created (if you wanted to create your result variable in this step, the inside would be number: result = input1 + input2) and add an arithmatic operator to add the two user input variables together. In step five we render the result variable. 

There you have your, albeit simple, flowchart. They get much more difficult as the task you need to achieve becomes more involved. In our next post we will dig deeper into flowcharting and look at loops and conditionals. 

Until next time :)
MDX - JSX in Markdown
Tags: coding, javascript, react
Published: 2018-08-29 13:25:48

---
title: MDX - JSX in Markdown
published: true
description: 
tags: coding, javascript, react
---

## What

There is a new markup-language on the block, called [MDX](https://mdxjs.com/), which is essentially [Markdown](https://daringfireball.net/projects/markdown/) sprinkeled with [JSX elements](https://reactjs.org/docs/introducing-jsx.html) and JavaScript `import`s.

## Why

If you read my [article about Storybook](https://dev.to/kayis/streamline-your-front-end-development-with-storybook--4m22), you know that can be nice to be able to run components on its own, without being embedded into an huge application. For example when you need to check if everythign still works or if you need examples for your [documentation](https://www.docz.site/).

Also, some applications are mainly text-heavy but need some more complex parts, like charts or animations, so writing them with Markdown would be a bit of a pain. For example [presentation slides](https://github.com/jxnblk/mdx-deck).

## How

To get up and running quickly, simply use this command:

```
npm init mdx
```

This will setup a [Next.js](https://github.com/zeit/next.js) project pre-configured for MDX. Then you can start to write your MDX documents.

Here a simple example:

```
import Graph from './components/graph'

## My Heading

A nice paragraph that tells people about some data, followed by a `<Graph>` 
component that visualizes this data.

<Graph />
```

- The `import` statement from JavaScript
- Heading and paragraph from Markdown
- JSX element from React

The nice thing is **everything is a component**, so you can even import other MDX and **even Markdown** files.

## Conclusion

MDX is a really interesting approach to make Markdown more flexible. Let's see what will be done with it in the future. :)
Replace JSX's opening tag and closing tag at the same time
Tags: vim, jsx, react, editor
Published: 2018-08-29 18:01:47

---
title: Replace JSX's opening tag and closing tag at the same time
published: true
description: 
tags: vim, jsx, react, editor
---

![image](https://thepracticaldev.s3.amazonaws.com/i/ce6utdca82pczd7f5fdz.gif)


Vim is my favorite editor, while React is my favorite frontend framework.

Of course I use Vim to edit my JSX files, but I saw my friend's WebStorm edit JSX tags easily. WebStorm can edit opening and closing tag simultaneously.

So I created my Vim plugin, `vim-jsx-replace-tag`. 

https://github.com/acro5piano/vim-jsx-replace-tag

This is a small Vim plugin but I can improve my productivity greatly. Indeed, Vim is my best editor.