teleren/devto huggingface dataset:
Say hello to three new DEV team members!
Tags: meta
Published: 2020-02-03 20:18:37

---
title: Say hello to three new DEV team members!
published: true
description: 
tags: meta
cover_image: https://thepracticaldev.s3.amazonaws.com/i/97a2sge9bgapcn6szuep.png
---

Last week, we brought many members of the DEV team to a [meetup](https://twitter.com/bendhalpern/status/1223057289214558209) in upstate New York. It was awesome seeing so many team members, IRL! Many of us were meeting for the very first time, but I want to highlight the *truly brave* ones amongst us: Julianna & Ridhwana. 

Last week was Julianna and Ridhwana's very first week at DEV and they flew halfway across the country and world, respectively, to be with us. We're so excited to 'officially' share that they've joined the team. 

Juliana has joined us an Associate Software Engineer and is based out of the United States: 

{% link https://dev.to/juliannatetreault/i-just-joined-the-dev-team-n2j %}

Ridhwana has joined us as a Software Engineer and is based out of South Africa: 

{% link https://dev.to/ridhwana/a-new-year-with-a-new-dev-adventure-9en %}

We're equally excited to share that Fernando Valverde has joined us *today* as a part-time core contractor, based out of Costa Rica. He's been a community member with us since _the early days_ and is now the company's go-to mobile expert:

{% link https://dev.to/fdoxyz/i-just-joined-the-dev-team-4pgb %}

Please give them all a warm welcome!
A new year, with a new DEV adventure!
Tags: meta, career, personal
Published: 2020-02-03 20:16:51

Hello, DEV Community👋🏽 I’m Ridhwana 👩🏽‍💻, and it's my first official week as a software engineer at DEV!

Learning and sharing, building communities and coding are mainly the things that I’m passionate about, and so I consider myself very lucky to be a part of the DEV team. 

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

In my past life, [I’ve worked on building out many physical communities](https://ridhwana.com/events/) (especially for minorities) so that I feel included and include others too. Hence, I am particularly excited to be a part of a community that is welcoming, inclusive, accessible, and can scale all around the world 🌍. 

I’m also an addicted [conference speaker](https://ridhwana.com/speaking/) and thrive on learning and sharing knowledge! On a side note, I keep a running leaderboard of the most ridiculous poses of myself talking 👽.

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

I live in South Africa 🇿🇦 which is a beautiful country. 

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


Living in South Africa allows me to apply myself to contribute to solving challenging problems that impact many lives. In my spare (not so spare) time, I  run a non-profit in the education space called [Kasi Maths](http://kasimaths.org/) that exposes students in under-resourced areas in South Africa to STEM, shows them how they’d use the subjects they learn in school in the real world, and allows them to explore new opportunities.

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

Finally, and most importantly I’m a hot chocolate addict (instead of a coffee one). I believe that the world (especially coffee shops) needs to learn the art of making a high quality hot chocolate, but let's first focus on solving one problem at the time!

![Hot Chocolate](https://media.giphy.com/media/KuFERqzDb0pxe/giphy.gif)

I'm so excited to be a part of this wonderful and friendly team!

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/0kspb5hyg2d7rz5mbu8q.jpeg)

Please always feel free to reach out and say hi 😊, you can find me here on DEV, on twitter (https://twitter.com/Ridhwana_K) or via email (ridhwana@dev.to).
Distributed thread pulling in software teams - teaching and learning from our colleagues
Tags: discuss, computerscience, productivity, career
Published: 2020-02-03 20:04:34

"Acknowledging you don't know something is the dawning of wisdom" - Charlie Munger

This is so difficult to do in the software world. If we don't know something, (it is expected that) we say nothing, look it up, read a wikipedia page, and come back to the conversation with an air of having known about the concept all along. (I have this visualization of xkcd comic where time is paused, dash to the keyboard, unpause time, start nodding).
 
In doing this, sometimes we fool ourselves too. I know all about distributed ledgers now (or document-orientated databases or GraphQL or SSL or DNS...). We squash the desire to go back and actually understand concepts at a deeper level. As developers we do have to walk a fine line. I wrote about [abstraction](https://dev.to/bhumi/how-abstraction-can-be-a-useful-yet-painful-concept-especially-for-beginners-28bk) and the constant need to be able to make use of something without understanding it fully. Suppressing curiosity at times is a necessary part of being an efficient get-things-done kinda developer. Other times we do have to dig deep to figure something out, especially while debugging. Where things are not working according to our expectation, pointing to a likely gap in our current understanding (OR a silly typo!). And these times can actually be enjoyable if allow for actual insight and wisdom to seep in!
 
I like the idea of pulling at threads to understand something deeper in my spare time. But this is not very efficient. There are only so many things I can get through in a week or month before I get exhausted or distracted.

So what if we could do this in a distributed way.

We could distribute this thread pulling activity and divide up topics among a team.  The thread pulling deep dives could take 1 to 2 hours each week and then we come back and share the learning with everyone. This could work. Couple things required to make this actually beneficial for all:

* Focus on collaborative understanding (not self-promotion or boasting) - every single person should be able to nod their heads. Really practice articulating the concepts well.  You are only successful if your teammates really 'get' it and have that aha movement.
* Focus on the most relevant sub category to the team's current work. Make it relevant to everyone in the team and make it relevant to your current project (so not computer science --> web development --> browser debugging --> dev tools)

Wouldn't it be really awesome if we all take the time to pull a thread and learn and teach each other in a real way.  With the common goal of appreciating the beauty hidden in software. I would love to be part of a software industry culture where this type of learning and teaching from team members is a common practice.

In my experience good things come from connecting the dots.

Have you tried a practice of learning and teaching within your teams?
I just joined the DEV team!
Tags: meta, career, news
Published: 2020-02-03 20:03:47

---
title: I just joined the DEV team!
published: true
description: I just joined the DEV team!
tags: [ 'meta', 'career', 'news' ]
---

About two and a half years ago I joined the DEV community with lots of hope to share what I know and learn from others. It's been quite a ride since then.

{% link https://dev.to/fdoxyz/hi-im-fernando-valverde %}

Now, with the same goals as before, I'm thrilled to share I'm officially joining the DEV team as a part time contractor!

I'll help enhance the DEV mobile apps, can't wait to see how __we__ can continue to improve the DEV mobile experience over time. I'm emphasizing __we__ because, in case you're not aware already, the Android & iOS apps are open source too!

Feedback, bug reports & PRs are very welcome :)

{% github https://github.com/thepracticaldev/DEV-ios %}

{% github https://github.com/thepracticaldev/DEV-Android %}

Pura Vida!
I Just Joined the DEV Team
Tags: meta, career
Published: 2020-02-03 20:02:24

Hi, DEV! 👋🏼

My name is Julianna and I am incredibly excited to announce that I have joined the DEV team as an Associate Software Engineer! This will be my second week working with the wonderful team behind DEV and I am thrilled to be here.

My first introduction to DEV was in September of 2018 while I was attending the Flatiron School’s full-stack software engineering bootcamp, but I didn’t seriously start using the platform until October of 2019.

I have been so inspired by the DEV community and cannot wait to give back to the amazing people who make DEV such a special place to be a part of.

### About Me
I am an East Coast native currently residing in the mountains of Colorado.

I began as a self-taught programmer, working on open-source software over three years ago and graduated from a full-stack software engineering bootcamp a little over a year and a half ago. 

Since graduating, I have primarily worked on the backend of the stack, focusing on Ruby and Rails development and I am currently teaching myself how to program in Python.

When I’m not writing code, I really enjoy reading, running, writing, traveling, and attempting to be a plant mom.


### Why DEV?
My resume is eclectic—I am a published writer turned software engineer, making DEV the ultimate intersection of my skills. Being able to do what I love, while still continuing to be immersed in the world of writing is a dream come true.

Coming from a non-traditional background, I cannot overemphasize how important it is to have an inclusive, supportive, and transparent community to learn and grow from, especially when you’re just starting out as a developer. 

Open-source software has been a large part of my journey as a developer. I first learned how to program through an open-source community and I began contributing (albeit, very minimally) to open-source within my first few months of programming. The open-source community was what made me feel comfortable as a new developer and helped me grow into the software engineer that I am today. Giving back to the community that gave so much to me is something I hold near-and-dear to my heart.

I am so dedicated to making sure that I do my part in maintaining what makes DEV the amazing platform that it is.

If you have questions, tips on how to care for succulents, or just want to get in touch, feel free to message me or email me (julianna@dev.to)! 👩🏻‍💻
Responsive web : progressive or constant values between breakpoints ?
Tags: css, design
Published: 2020-02-03 19:50:13

Hello,
According to you, is it better to use  progressive or constant values between  breakpoints.

For example : 
font-size for an element :
before 767px (width of the portview) : 32 px.
after 767px : 68px.
the max width of the main container : 1300px

Would it be better to make the value of the font-size progressive from 32px to 68px depending on the width of container (from 767px to 1300) ? Or to keep it constant (68px).

Thank you.
Module 7 Project 1
Published: 2020-02-03 19:35:28

HTML
<!DOCTYPE html>
<html5>
   <head>
</head>
   <body>
      <h1>Here are some colored paragraphs!</h1>
     <p1><strong>This is the first paragraph.</strong> Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p1><p>
     <p2><strong>This is the second paragraph.</strong> Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p1><p>
     <p3><strong>This is the third paragraph.</strong> Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p3>
   </body>
</html5>


CSS
<style type="text/css">
         h1 {color: #005a9c}
         p1 {color: #ff0000}
          p2 {color: #00aa00}
          p3 {color: #0000ff}
      </style>
Why Monad Composes Operations Sequentially
Tags: functional, monad
Published: 2020-02-03 19:16:02

You can keep reading here or [jump to my blog](https://odone.io/posts/2020-02-03-monad-composes-sequentially.html) to get the full experience, including the wonderful pink, blue and white palette.

---

When learning new stuff, a great strategy is skipping what's unclear at the moment and coming back later. It's a bit like doing crosswords, things get more clear as they are tackled from more than one perspective. Knowing what comes before and what comes after, makes it easier to grasp the concept that stands in between.

I've heard multiple times that monads are like semicolons. In other words, they allow things to happen in a serial fashion. The part that I could not understand was why people kept saying that it's clear by looking at `bind`'s type signature:

```hs
(>>=) :: forall a b. m a -> (a -> m b) -> m b
```

I've been in the dark for a long time, until a few days ago it clicked. So here I am, writing the post my past self would have loved to read.

First of all, let's dissect the type signature a bit:

```hs
(>>=) :: forall a b. m a -> (a -> m b) -> m b
--                   ^ Start
--                           ^ Step
--                                        ^ End
```

We start with a `m a` and using a step function we advance to `m b`. For that to happen we need to apply step to the value `a` that is in `m a`.

It's important to remind ourselves what `m a` means: a monadic operation that eventually computes a result of type `a`. In other words, until the result is not "produced", there's no way the step function can be applied. That is why bind sequences operations!

Using the Maybe monad that would look like the following:

```hs
sequence :: Maybe Int
sequence = do
  x <- somethingThatReturnsMaybe
  y <- somethingElseThatReturnsMaybe x
  y+1
```

The `do` notation gets translated to:

```hs
sequence :: Maybe Int
sequence =
  somethingThatReturnsMaybe       >>= \x ->
  somethingElseThatReturnsMaybe x >>= \y ->
  y+1
```

Both `somethingThatReturnsMaybe` and `somethingElseThatReturnsMaybe` use Maybe because in some cases they succeed (return Just a value) in some others they fail (return Nothing). In the former case, `somethingElseThatReturnsMaybe` to  run needs `somethingThatReturnsMaybe` to produce the value `x`. In the latter, the Monad instance for Maybe makes `bind` short-circuit and early-return a Nothing.

---

Get the latest content via email from me personally. Reply with your thoughts. Let's learn from each other. Subscribe to my [PinkLetter](https://odone.io#newsletter)!
Quick Tips - Coding with Ruby
Published: 2020-02-03 18:59:23

My name is Antonio Blandin and I'm new to Ruby Programming. With all of my 3 months experience, I would like to share what I used to help me trek through this programming adventure. There are so many sticky notes scattered across my laptop home screen, both physical and digital. Here are some of the main ones I use as reference when deciding how to tackle an issue. 

When iterating through an array, .each is always a good go-to method when you don't need the array to be modified.  With .map, no matter what action you performed with the elements, the original array will not be modified and it will return the modified array. The method .each will not do that. 

When looking for certain elements, there's many ways to go about this. We can use the .include? method to return true or false, letting us know if the given string or character are included or not. To have the actual element return to you, .find is used to grab the first element that compares true to the element that you're looking for. When it's time to grab multiple elements, .select is the way to go. This will iterate through the array and for every element that returns true, it will be added to the output that is returned. Reject does the opposite of select. The output will be the array with the certain elements removed. 

each 

 - ex. [1,2,3].each {|x| print x.to_s+’!’ }
   prints 1!2!3! 
   returns [1,2,3]

map 

- ex. [1,2,3].map {|x| x*3 }
   returns [3,6,9]

include? 

 - ex. “Hello”.include? “lo” => true
 - ex. “Hello”.include? “ol” =>false

find 

- ex. [1,2,3,4].find { |num| num / 2 == 2 }
  returns 4 

select 

 - ex. [1,2,3,4,5,6,].select { |num| num%2 == 0 }
   returns [2,4,6]

reject 

 - ex. [1,2,3,4,5,6].reject { |x| x == 2 || x == 5 }
   returns [1,3,4,6]
For Loop – JavaScript Series – Part 14
Tags: javascript, codenewbie, tutorial, beginners
Published: 2020-02-03 18:52:48

In last lesson we learn about the while loop, but there is a another loop which is really popular and people use this. So we’re going to learn it too.

Suppose we are going to print 1 to 10 on the console. But how we can do it ? We can do it easily
```
console.log(1)
console.log(2)
...
console.log(9)
console.log(10)
```
But this is not a good way to do it. Currently we can do it because it’s only ten times. But suppose we need to print 1 – 100. How to do it ?

This is where we use loops. We’re going to use For loop today!

For is easy. Just remember what we learned in our last tutorial. For loop syntax is –
```
for (initial, condition, increment/decrement/rulesBreaking) {
  // code block to be executed
}
```
Let’s write some real codes now. If we wants to print 1 – 10 then we are going to store the values in variable and we are going to start from 1. We can directly do this part in for first part!

Now we are going to start our for. For then first part will be initial of the number, then condition for breaking the loop and final part will be how we can break the loop.
```
for (var number = 1; number < 11; number++) {
  // code block to be executed
  console.log('Printed number - ', number)
}
```
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/j7xz6pnl3ofhbmeee76t.png)

By the way did you notice that I used number++ ? What that’s mean ?
number++ = (number = number + 1) same thing. number++ is just a shortcut way to write it.

See the result in browser.

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

Do you understand the For loop ?

You can see the graphical version here
{% instagram B8HVux7gCSG %}

Source Codes - { Check commits }
{% github nerdjfpb/javaScript-Series %}

Originally it published on [nerdjfpbblog](https://blog.nerdjfpb.com/javascript-part-14/). You can connect with me in [twitter](https://twitter.com/nerdjfpb) or [linkedin](https://www.linkedin.com/in/nerdjfpb/)!
Develop empathy
Tags: letterstoanewdev, empathy, frustration, beginners
Published: 2020-03-06 20:26:25

---
title: Develop empathy
published: true
date: 2020-02-03 13:56:02 UTC
tags: letters to a new dev,empathy,frustration,beginners
canonical_url: https://letterstoanewdeveloper.com/2020/02/03/develop-empathy/
---

Dear new developer,

Right now you’re probably a bit frustrated and confused. You’re learning a lot of things and you don’t really understand everything. Sometimes things click and it all makes sense, other times you’re confused and staring at what feels like a brick wall. Perhaps you just want to make things work and they won’t.

**Good**.

I say that not because I’m a sadist or dislike you. I say that because I hope you’ll remember the frustration you are experiencing right now. I think that will make you a better developer.

**Why?**

Because that is the state of 99% of your users. Whether they are a business employee or a person trying to use your app for personal reasons. They are just trying to finish a task and get on with their life. The software you are writing is the tool they are using to do that.

- They don’t care about elegance of code.
- They don’t care how much you love to develop.
- They don’t care if you are learning and growing.

They just want to finish their job, complete their task, do their thing.

And, honestly, the tools we provide are frustrating. They’re buggy. They’re slow. The fact that they are amazing compared to what we could create a few years ago and that they are better than the alternative is beside the point.

I don’t write this to cause despair, new developer. Progress is being made. But it’s made one person at a time. Each person has to act with empathy toward their frustrated users. Understand them. **Care** about them.

And if you can remember the frustration you are currently encountering, perhaps you’ll have just a bit more empathy toward your end user, who is just trying to use your work product to get something done.

Sincerely,

Dan
Sanitizing console.log from HTML using ColdFusion Regex
Tags: regex, coldfusion, debugging
Published: 2020-02-03 18:50:40

I have some ColdFusion applications that contain javascript [console.log](https://developer.mozilla.org/en-US/docs/Web/API/Console/log) debugging.  In many cases, I didn't want to remove the code as it is beneficial for internal developers, but it didn't make sense for it to be displaying messages for the general public. Instead of adding [CFIF](https://cfdocs.org/cfif) tags around every usage, I determined that it may be a good idea to use regex to sanitize it.

I initially tried removing the logging and/or replacing it with a comment, but this didn't seem to work correctly in every context. I decided to set it to a local dummy variable so this it wouldn't do any harm during post-processing.  We use [jsoup](https://jsoup.org/) to manage the order of JS/CSS loading & add pre-configured CSP rules based on content. In addition, We may use [IIS Webspeed](https://www.iiswebspeed.com/) ([PageSpeed](https://developers.google.com/speed/pagespeed/module) for IIS) to reduce whitespace optimize css/js/images.  (PageSpeed automatically removes comments & reduces JS, so I'm hoping it will reduce multiple redundant variables to a single variable.)

Using the [removeLogging() UDF](https://gist.github.com/JamoCA/fee255d6cbdf444e04dfda6a944e56b1), I can now determine how the web application is being accessed (developer vs non-developer) and remove the console debugging for non-developer visitors. This has been tested using CF2016.

## Source Code

{% gist https://gist.github.com/JamoCA/fee255d6cbdf444e04dfda6a944e56b1 %}

## TryCF.com Demo

[https://trycf.com/gist/fee255d6cbdf444e04dfda6a944e56b1](https://trycf.com/gist/fee255d6cbdf444e04dfda6a944e56b1)
Typescript - simple model/collection package
Tags: typescript, tutorial, beginners
Published: 2020-02-03 18:45:58

Recently, while I was learning about typescript generics I decided to write simple [package](https://www.npmjs.com/package/pera-trta) for models and collections. *Code sneak peek bellow:*

```typescript
import { Model } from 'pera-trta';
import { Collection } from 'pera-trta';

interface ICategoryProps {
	id: number;
	name: string;
}

class CategoryModel extends Model<ICategoryProps> {}

class CategoryCollection extends Collection<CategoryModel, ICategoryProps> {}

const cc = new CategoryCollection();
const c1 = new CategoryModel({ id: 1, name: 'pera' });
```

Package provides basic functionalities for models and collections by simple extending those classes.

Some of the functionalities that package provide are:

- IntelliSense support
- CLI support
- get model property by key
- update some properties of the model
- update only one model property
- store models in the collection
- sort collection items
- find particular item/items
- map collection items ...

For more information about the package including the CLI support, and examples visit [npm page](https://www.npmjs.com/package/pera-trta).

Thank you for reading and if you have any suggestion please feel free to reach out.