teleren/devto huggingface dataset:
What CSS framework would you recommend to pick-up in 2020?
Tags: css, discuss
Published: 2020-01-27 20:16:24

---
title: What CSS framework would you recommend to pick-up in 2020?
published: true
description: 
tags: css, discuss
---
So far I've tried just Bootstrap and a bit of Bulma.

Tho there are Tailwind, Foundation, Materialize, Skeleton and many others (most of them I have not even heard before).

I'm interested to hear what's your CSS framework of choice for this year and the main reasons behind your choice?
What Happens when you click your mouse
Tags: architecture
Published: 2020-01-27 20:12:47

If You're coming from a coding background, a mouse click is something you might take for granted. To successfully code an application, we don't need to understand how a mouse click or keypress works, or we might assume we do know at a high level. But when you dive into computer architecture complexity spirals just as quickly as it does when learning code. Today, I want to simplify while giving a still accurate account of what happens when someone clicks their mouse because as long as we're writing thousands of lines of code that depend on user interaction, it would probably nice to know how we're even allowed to interact with those events in the first place. 

So, what does happen when a user clicks their mouse? It might go to the event loop or to a handler, but for that to happen first the OS would have to be aware. I mean, how does your computer even know the mouse was clicked in the first place?

Well, how might a computer listen for something like a mouse click. The mouse, upon being clicked, could be wired to change a bit somewhere or file. And if we did that, we could have the computer (the processor) check that file every so often. If it's been flipped from a 0 to a 1, we'd know that the mouse was clicked. But how often would we want to check that file? In a game, we might want to know about clicks every microsecond, and checking a file that often is certainly going to waste energy and processing power. If we check it less often, to be more efficient, we risk a sluggish user interface, not noticing clicks until noticeably late. This is a system that was used in the past and used for other things still. It's called Polling.

Of course, its problems in our use case are apparent from what I listed above. So, we need something better. Well, in the case of polling, the mouse changes something and the processor reacts, but the processor doesn't react until it checks that bit on its schedule. The processor is the prime mover. What would a system where the mouse is the primary mover look like? I suppose the mouse could send a signal directly to the processor. And indeed, that is how our modern systems work.

It's called an interrupt. The mouse or hardware device will send a signal directly to the processor when an event occurs. The Processor must then handle the signal, immediately. This means the processor will pause in whatever function it is running, saving where it is at in the code, and handle the click right then. Afterward, it goes back to the state it saved and continues as if nothing had happened.

Because every hardware event is completely pausing the processor, it's important to handle them as quickly as possible. So, part of the operation then is to do only the minimum amount to document the click, before continuing with the workload. Essiantly, the processor saves the info about the click event and passes it to the Operating Systems scheduler. The OS scheduler will then decide what else needs to be done about it, based on priority and complexity.
How YOU can learn Serverless with .NET Core and C#
Tags: serverless, dotnet, webdev, graphql
Published: 2020-01-27 20:05:38

---
title: How YOU can learn Serverless with .NET Core and C#
published: true
description: This teaches you Serverless with .NET Core. Things we cover are how to work with database, GraphQL and much more.
tags: serverless, dotnet, webdev, graphql
---


Follow me on [Twitter](https://twitter.com/chris_noring), happy to take your suggestions on topics or improvements /Chris

[Sign up for a free Azure account](https://azure.microsoft.com/en-us/free/?wt.mc_id=devto-blog-chnoring)
To create Serverless Azure Functions you will need a free Azure account

[Starter guide .NET Core](https://dev.to/dotnet/how-you-can-get-started-with-net-core-and-c-in-vs-code-30gc)
Completely new to .NET Core? Then start here. It will tell you all about how to use the CLI to scaffold projects, run and build them.

[Serverless + GraphQL](https://dev.to/azure/how-you-can-build-a-serverless-api-using-graphql-net-core-c-and-vs-code-g5h)
This shows how you can build a GraphQL API in Net, we also show mutations. The article then proceeds to host the GraphQL API in a Serverless app.

[Serverless app in .Net](https://dev.to/azure/how-you-can-create-a-serverless-api-in-c-and-net-1ie)
Building a Serverless REST API is quite easy using Azure Functions and some great plugins in VS Code. This is the 10-20 min of coding, depending on your caffeine level ;) Getting to use .NET and C# while building is even greater

[Serverless App using CosmosDB and database bindings](https://dev.to/azure/how-you-can-build-a-serverless-net-core-api-in-no-time-with-bindings-and-cosmosdb-2eg8)
Bindings are a great feature in Serverless that takes care of connecting to your data source. Writing a CRUD API is super simple thanks to it.
The 7 Most Popular DEV Posts from the Past Week
Tags: top7
Published: 2020-01-27 20:01:03

---
title: The 7 Most Popular DEV Posts from the Past Week
published: true
description: A round up of the most-read and most-loved contributions from the community this past week.
tags: icymi
cover_image: https://thepracticaldev.s3.amazonaws.com/i/sfwcvweirpf2qka2lg2b.png
---
Every Monday we round up the previous week's top posts based on traffic, engagement, and a hint of editorial curation. The typical week starts on Monday and ends on Sunday, but don't worry, we take into account posts that are published later in the week. ❤️

#1. An Unveiling

Maël gives us an in-depth look at the first stable release of Yarn 2. We learn about core updates, new features, and breaking changes

{% link https://dev.to/arcanis/introducing-yarn-2-4eh1 %}


#2. Squash It!

Erika shares a comic to help us better understand interactive git rebasing.

{% link https://dev.to/erikaheidi/pick-squash-drop-rebase-comic-607 %}


#3. Flex Your Skills

Elisabeth goes over what makes for a great side project and explains how to talk about your projects on your resume and in interviews.

{% link https://dev.to/coderbyte/how-to-build-a-side-project-that-will-impress-future-employers-nl2 %}


#4. Troubleshoot

Jeremy shares practical advice on the art of debugging. We learn to train our eyes and to not trust documentation 🙀.

{% link https://dev.to/dotnet/the-secret-art-of-debugging-1lfi %}


#5. First Foray

Matt tells us about their first foray into working with a major open source project. In this post, Matt touches on their process and the amazing feelings of pride that hit them.

{% link https://dev.to/integerman/how-to-contribute-to-open-source-software-4pbl %}

#6. Deep Dive

Justin takes a deep dive into the DEV codebase to answer one question: What is the algorithm for dev.to's feed?

{% link https://dev.to/piannaf/the-dev-to-feed-algorithm-5em5 %}

#7. Good Grasp

Reed shares five projects that can help bridge the gap between knowing the fundamentals of React and becoming a professional developer.

{% link https://dev.to/codeartistryio/5-react-projects-you-need-in-your-portfolio-1c3b %}

_That's it for our weekly wrap up! Keep an eye on dev.to this week for daily content and discussions...and if you miss anything, we'll be sure to recap it next Monday!_
Ara issue of the week
Published: 2020-01-27 20:00:53

Well I am back again, here are the issues we are looking at
{% github https://github.com/FultonBrowne/Ara-android/issues/169 %}
and on the server side of things
{% github https://github.com/FultonBrowne/Ara-Server/issues/76 %}

if like my work please [buy me a coffee](https://www.buymeacoffee.com/28EcqNL)
UtahJS 2019: Why small is better than big
Tags: javascript, utah, conference
Published: 2020-01-27 19:58:09

If I had to summarize UtahJS with one word, it would be “human.”

How can a conference not be human, you may ask. Well, if you have ever attended re:Invent, you might see what I mean. Don’t get me wrong. AWS conferences are awesome. The presenters are unmistakably smart, the topics are compelling, and the hype is palpable. Personally, I still can’t get over the fact that last year there were DJs scattered throughout some of the venues playing sick tunes at 9 am. But re:Invent became overwhelming with its 40,000+ attendants, thousands of sessions, and the five hotels where it takes place.

UtahJS, on the other hand, is compact. The conference occupies only a small fraction of a multiplex in the suburbs of Salt Lake City. A volunteer told me that they expected about 400 people this year. And that’s one of the reasons why I enjoyed this conference so much. People were approachable and open to talking to strangers. In fact, I met more people at UtahJS in a day than I did at re:Invent in a week. Conversations were rich and interesting, including a discussion that got very technical about parsing DNS packets, another one where we commiserated on third-party dependencies (I’m looking at you, Lab On Demand), and also one about the vitality of the tech community in Utah.

The pace of this single-day event is fairly fast. Starting at 10 am, you can choose to attend one of three simultaneous presentations every 20–30 minutes until 5 pm. But everybody was so relaxed. In fact, people are so relaxed that the organizers incentivize people to move more quickly from one theater to the other by giving away prizes right at the beginning of each talk. This small touch creates such a fun and memorable experience. Even the sponsors, who are invited to present their company in person at the beginning of the conference, ditch the dullness of marketing talk to some extent and expose themselves in a very personal, vulnerable way.

From React Suspense to imposter syndrome, the topics covered in the 2019 edition of the conference were pretty eclectic. My choices were driven by what I like to call the 3 learning phases: discovery, improvement, and confirmation. In other words, my goal was to explore concepts that were somewhat new to me (such as idempotency and resiliency), improve in domains where I knew I could easily progress (namely, code reviews and algorithms), and reinforce knowledge that I acquired from previous experiments (e.g., web sockets and designing vanilla JavaScript applications). Since the talks are so short, don’t expect to go deep into a particular question. However, I got very clear takeaways from each speaker, with ideas and tools to explore at my leisure.

To put it in a nutshell, I think that UtahJS is a great conference which shows a lot of humility. The atmosphere was playful and respectful. Even if the pace was somewhat fast, I wasn’t overloaded with information. At the end of the day, I had discovered new perspectives that will undoubtedly contribute to the improvement of my skills as a software engineer. What else can you ask for?
Settings for Making Python CLI-tools on Windows
Tags: python, cli, setup, windows
Published: 2020-01-27 19:57:35

In the previous post of this series, I showed how to set up a folder for our own CLI-tools in Windows. Now I will cover some settings which make CLI-tools written in Python work with that setup.

## Make Python the Default Program for .py-files
First, make sure you set the default program for opening .py-files to Python. To change this you right-click a .py file, go into _properties_ and change _opens with_ from what you currently have to _Python_.  This will allow you to just write the name of the file to run it from the terminal. 
So you can write this:
```
PS> my_tool.py
``` 
instead of this:
```
PS> python my_tool.py
```
This might seem like a rather small improvement in the amount of typing. However, it has a much more important effect which relates to the last post in this series. If you followed along with the last post and have the bin-directory setup, this part is important. As if you added a python file to that folder and then tried calling it using the python command you will have gotten an error. This is caused by the python command only looking in the current directory and not in your path. What is so nice about being able to run the script by just writing the file-name is that it solves this problem. Now you can just create a python file, drop it in the bin-directory and call it from anywhere. Success!

## Adding .py-files to _PATHEXT_
As you might have noticed in the example above I used the PowerShell (PS) prompt. At home I am currently running cmder, however, at work I am running PS. This made me notice an annoying problem, where when I started a python script from PS it spawned and executed the script in a new window. It wrote nothing to the PS terminal and the window closed as soon as the script finished. I found the solution to this problem was to add _.PY_ to the semi-colon separated list of file-endings in the system environment variable _PATHEXT_. If you don't know where you can change the environment variables, check out the first post in the series. When you are finished your _PATHEXT_ probably looks something like this:

![Screenshot with the text PATHEXT a large space before the text .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PY](https://thepracticaldev.s3.amazonaws.com/i/pyc1rh2na4ato9cleqo5.PNG)

Adding the extension to this list marks it as an executable file-type. A side-effect is that this allows you to run the python files without writing the _.py_ extension.  Continuing with the example from earlier:
```
PS> my_tool
```
However, because of autocompleting in Windows really liking file-extensions you will probably not notice much of this side-effect.

## Final Notes
These are the main struggles I went through when setting up my Windows environment for using Python scripts as CLI-tools. It actually took multiple attempts to find these solutions and I hope this might help anyone struggling with the same issues. If you have encountered any other issues when running python on Windows, please let me know in the comments and we can attempt to solve it together.
The library that allows to use JavaScript as the query language for your API
Tags: graphql, webdev, api, rest
Published: 2020-01-27 19:43:52

---
title: The library that allows to use JavaScript as the query language for your API
published: true
description: A small introduction + source code at the end
tags: graphql, webdev, api, rest
---

Working in the field of software engineering for a decade, I experienced the rise and fall of SOAP, adopted REST and assessed GraphQL. The web race is for speed, every new alternative technology adopted today is justified only if it makes our web applications faster, more efficient, maintainable and more scalable.

GraphQL became a good candidate to avoid the problems I had when implementing APIs using REST. Some of them are, over-fetching, under-fetching and back-end negotiations on status codes and HTTP verbs.

In the first attempts to use GraphQL, I began to worry about performance issues around N + 1 queries, so, instead of continuing to spend more time reading an extensive and well-written specification and recipes for problems that I have not yet encountered. I decided to create my own library to query APIs regarding the following goals:

1. Low learning curve (easy to pick and use).
2. More efficient than existing tools(faster).
3. Straight from the web (not a new language or specification, just augment what we have today).
4. More freedom for the API consumer (allow the consumer to specify exactly what they want).
5. Predictable query cost (increase consumer awareness and responsibility, related to goal 4).
6. Don't reinvent the wheel (this really doesn't matter to me, however, it also works as a motivation).

With that in mind, and several proofs of concepts, I thought I could query the APIs using JavaScript as a query language. That's it, without proposing a new DSL. Let's take into account that there are enough specialized query languages for APIs ​​out there, the most noticeable, GraphQL, Falcor, OData, restQL. The intention was just send the JS code to the server à la PostgreSQL DO or Redis eval. It is a crazy idea, but at the same time it became a hard to ignore challenge.

I end up with a TypeScript library for NodeJS and the browser which allows to query API in the following fashion:

```ts
const getArticle = func(async (slug: string) => {
  const { name, date } = await BlogApi.getArticle(slug)
  return {
    name,
    date,
  }
})

getArticle('fancy-slug').then(...)
```

[Remote-func](https://github.com/yosbelms/remote-func) not only met the proposed objectives. It also,

1. Makes end-to-end type safety possible if used with TypeScript.
2. Allows greater independence between frontend and backend developers.
3. Can fetch multiple resources at once.
4. Allows to reduce the data before sending the response to the client.
5. Can batch and deduplicate requests.
6. Can stream data from server to client in a single HTTP response, and dispatch in the order of arrival.

And a little more features that you might find useful.

[Source code](https://github.com/yosbelms/remote-func)
Am I a Developer yet?
Tags: beginners, career, todayilearned
Published: 2020-01-27 19:23:40

Today I hit a big landmark in my journey transitioning into Web Development: I received a call this morning from a recruiter regarding a Junior-level Front-End-based role. I've been studying Web Design, App Development, CMS, front-end, back-end (you name it, I've tried it) for almost 5 years now. Prior to my interest in all things web-related I was a line cook, food server, restaurant manager, customer service representative and homeschool mom. I've gotten great at managing time, creating schedules, handling money, and assisting customers. But did I ever think I'd be capable of eliminating bugs from software or creating responsive web sites? Not so much. My brother was the technical one growing up, playing PC games and taking apart computers. It was never 'supposed' to be for someone like me. However, in High School and College I had a lot of interest in Graphic Design and often dabbled with Illustrator and Photoshop. On most days, I feel VERY comfortable playing with code; it feels as if it's something I shouldn't have waited until my 30's to pursue. On the other days, I still see myself as an outsider. 

Fortunately, before my landmark phone conversation this morning, I had read a great blog post which specifically addressed this psychological problem:

https://dev.to/juanfrank77/how-to-forget-about-imposter-syndrome-1d79


Do I feel I'll be offered the job? Not necessarily. However, it was a great experience to be forced to look back on the progress I have made and I'm excited to continue learning new skills. Those Bootcamps, code-alongs, projects, and code snippets really do add up over time! So am I a Developer? Of course! And here's my justification:

*ONLY YOU CAN DECIDE WHO YOU ARE*

Imposter Syndrome is real, and we don't deserve to do this to ourselves. Of course you're still learning, everyone is. It's important to note that the learning never stops. You won't just become an expert one day and seize to ask any more questions. There'll always be something new to learn. Burnout is common and can also add to feelings of self-doubt. I try to reserve one whole day each week as a break from programming. It usually isn't a 'whole' day, and I can't help myself from working on codepen projects here and there...but the break from courses and documentation is great for rejuvenating both mind and body. 

This was my first post. Too often, I refrain from socialization and the lack of communication has hindered my growth. One of my goals in further developing myself is to ask more questions, share more input, and connect with more people. 

Thank you so much for reading!
CFP: The search for HashiConf EU speakers has begun
Tags: techtalks, challenge, devops, hashicorp
Published: 2020-01-27 18:50:26

HashiCorp is looking for speakers for the upcoming HashiConf EU in Amsterdam, June 8-10, 2020.

If you have a technical talk showcasing how you used a HashiCorp product to solve a problem, what challenges you faced, and the workarounds you found to solve them, we would love to hear from you. We value technical deep-dives, stories of how you use our technology, and retrospectives from your failures!

Apply here: https://hashiconf.com/eu/

Topics we’d love to hear about:

Topics may range from the internals of our software to high-level use cases. Talks do not have to be exclusively about HashiCorp products, they can cover the broader industry and non-technical topics as well. Topics we love to hear more about include:

*Scaling distributed and microservice environments, including service discovery, networking and container schedulers
*Solving security and secret bottlenecks
*Managing infrastructure across hybrid and multi-cloud, as well as cloud migrations
*Introducing Infrastructure-as-Code to on-prem environments
*Dynamic application configuration at runtime
*Emerging architectural patterns, like service mesh and serverless
*Organizational impacts of DevOps and *Infrastructure-as-Code

Session formats:

Talks will be 30 or 50 minutes. 30-minute talks are ideal for implementation and customer stories, while 50-minute talks are great for technical deep-dives. Please keep your session to-the-point, only including relevant context. More concise talks often bring more value to the audience.


If you have any questions now covered in the CFP, you may reach us at speakers@hashicorp.com.

Good luck!
Starting an AWS Step Functions State Machine from Java
Published: 2020-04-09 15:46:46

---
title: Starting an AWS Step Functions State Machine from Java
published: false
date: 2020-01-27 18:41:00 UTC
tags: 
canonical_url: http://blog.iamjkahn.com/2020/01/starting-an-aws-step-functions-state-machine-from-java.html
published: true
---

Just over two years ago, I wrote a quick post to document [how to invoke an AWS Lambda function from Java](/2017/11/invoking-an-aws-lambda-function-from-java.html). I recently was asked how to start execution of an AWS Step Function state machine and also found a working example challenging to dig up … so I put together a quick example:

```
import com.amazonaws.regions.Regions;
import com.amazonaws.services.stepfunctions.AWSStepFunctions;
import com.amazonaws.services.stepfunctions.AWSStepFunctionsClientBuilder;
import com.amazonaws.services.stepfunctions.model.StartExecutionRequest;
import com.amazonaws.services.stepfunctions.model.StartExecutionResult;
import org.json.JSONObject;

// ...

// (1) Define the AWS Region in which the function is to be invoked.
Regions region = Regions.fromName(System.getenv("AWS_REGION"));

// (2) Instantiate AWSStepFunctionsClientBuilder to build the client
AWSStepFunctionsClientBuilder builder = AWSStepFunctionsClientBuilder.standard()
                                          .withRegion(region);

// (3) Build the client, which will ultimately do the work
AWSStepFunctions client = builder.build();

// (4) Construct the JSON input to the state machine
JSONObject sfnInput = new JSONObject();
sfnInput.put("key1", "hello");
sfnInput.put("key2", "world");

// (5) Create a request to start execution with needed parameters
StartExecutionRequest request = new StartExecutionRequest()
                                      .withStateMachineArn("MY_STATE_MACHINE_ARN")
                                      .withInput(sfnInput.toString());

// (6) Start the state machine and capture response
StartExecutionResult result = client.startExecution(request);

// (7) Handle the result, this includes the execution ID

```

The example above makes use of the `DefaultAWSCredentialsProviderChain` to pull credentials from environment variables, instance profile, etc. You can use `BasicAWSCredentials` if you need to hardcode keys, but this is a much less desirable option.