teleren/devto huggingface dataset:
Rintagi Low-Code Generated ReactJS Applications: The Future is Reactive
Tags: react, javascript, sql, csharp
Published: 2019-10-23 20:25:46

Building full-fledged, reactive mission-critical applications from scratch require a lot of effort, time and multi-talented technical resources.

[Rintagi](http://www.rintagi.com), the open-source low-code development platform from [Robocoder](http://www.robocoder.com), empowers anyone to quickly create CRUD screens with built-in user permission management, easily deploy-able to web and on-premises without writing a single line of code. Additionally, it enables users with basic technical skills the flexibility to customize the application to suit unique business requirements, by implementing custom business rules in industry-standard code.

The team at Robocoder realized that in today’s fast-paced digital world, it is important to empower developers with tools and smart technology that can ultimately increase efficiency and boost productivity - all the while ensuring that applications developed can be rejuvenated to stand the test of time.

With this in mind, the Rintagi platform now offers developers the ability to generate a superior 'React' experience within just minutes for new and existing screens and modules; resulting in engaging, responsive, mobile-first user interfaces within minutes (with built in [PWA](https://developers.google.com/web/progressive-web-apps)), while also having full access to desktop-centric asp.net web interfaces for complex interactions.

![React](https://github.com/Rintagi/Low-Code-Development-Platform/raw/master/PressImages/React-Gif1.gif)

Rintagi utilizes the ReactJS framework combined with the ease, speed, and efficiency of low-code development to build data-rich interfaces that adapt to changes in real-time for superior user experience. Teams developing applications using Rintagi develop once to generate both mobile-first and native web experiences effectively closing the gap between mobile and web development.  This allows future proof applications to get ready-to-market faster while being built on top of industry-standard architecture and best practices - no lock-in.

![ReactJS](https://github.com/Rintagi/Low-Code-Development-Platform/raw/master/PressImages/React-Gif2.gif)

Start your custom project today! Read our [user guide](https://www.rintagi.com/docs/site/index.html) for detailed instructions on installation and watch our [training videos](https://www.rintagi.com/video.aspx). Join our [community](https://gitter.im/Rintagi/home) to ask any questions you may have.

{% medium https://medium.com/rintagi/rintagi-low-code-generated-reactjs-applications-the-future-is-reactive-e430319687ef %}
How to use the terminal & github to make a pull request
Tags: codenewbie, womenintech, beginners, github
Published: 2019-10-23 20:15:07

I recently learned how to use the terminal with github (thanks to the very lovely people at codebar Birmingham!) I had to write down all the commands otherwise there is no chance I'd remember them all. There they are:

To update the fork on my machine (bring down all the changes from the repository on github so I have the most up to date version to work with) - You don't need to do this if you're the only one working on the project as it'll always be the most up to date version.
```
git checkout master
git pull
```

```
git pull upstream master 
```


If you make changes to the files and want to make a pull request, this is the sequence of things you need to do:
1) To see changes you've made
```
git status
```
2) Add the file to the next commit
```
git add nameofthefile

OR if you want to add all files in the directory including new ones

git add .

ORRR if you want to add all files and new ones in the directory and also any other files in other directories within this root folder

git add --all
```
3) Repeat step one to see the changes you've made that have now turned green (or changed colour depending on terminal settings?)
```
git status
```
4) Type the following and then type out your commit message. Best to do this in bullet points and if you're fixing a particular issue - include 'Issue #24' for example to link it to the issue.
```
git commit
```
5) In terminal the ^ arrow means ctrl. So click ^o to write code (save)

6) I didn't need to change the file name for this so then pressed enter and ^x

7) So far you've only sent it to the git on your computer - now you need to send it to the repository/fork on GitHub, so type:
```
git push
``` 
8) Now open your browser and go to the github website.
9) Go to my repos and open up the one you're working on.
10) Click on pull requests
11) Select 'New pull request'
12) Type in any extra detail needed and send. Then that's it.


To add an extra page to a repo, just copy and paste a current one in my own folder on my comp, change what needs changing and then do as above. 

To make my own github repo:
1) Click 'new' the github site and initialise with readme file.
2) Clone it.
3) Make a folder on my comp and locate it in the terminal. From inside that folder, type:
```
git clone https://github.com/helen8297/Helensfirstgithub.git
```
4) When making changes, complete the above and then when you've done git push, that has sent it and that's it. 

Useful future tip:
If I ever get a new computer, type the following in to do something good in the terminal - no idea what it means.
```
git config --global core.editor "nano"
```
Flutter/Dart ORM?
Tags: flutter, dart
Published: 2019-10-23 19:51:28

Does anyone have experience with using an ORM in their Flutter app? I'm planning on using SQLite for a local app database. It seems like the two frontrunners in this area are:

* [jaguar_orm](https://github.com/Jaguar-dart/jaguar_orm)
* [angel](https://github.com/angel-dart/orm)

Have you used either of these (or different) and how did it go?
Forms, ActionView, and the move to form_with
Published: 2019-10-23 19:37:33

Forms are what make up the user experience online.  From logging into your favorite website, to changing what you want to see, to logging out, forms are were most of this work takes place.

Traditionally this has been done with the <form> html tag.  For example:
```
<form action=“/user” method="get">
  Name: <input type="text" name="name"><br>
  <input type="submit" value="Submit">
</form>
```
With Ruby on Rails, Action View provides a number of helper methods which make writing out form tags a bit easier, and in some cases directly relate them to the models one could be working with.  

form_tag

With embedded Ruby a simple form field can be written out quite easily.  For example:
```
<%= form_tag users_path do %>
  <%= text_field_tag :name %>
  <%= submit_tag %>
<% end %>
```
Action View makes working with models, and their associated attributes even easier.

form_for

The form_for helper made learning Rails incredibly easier for me.  Providing a model in the form & having that form automatically have access to the model’s attributes was a dream come true.  For example:
```
<%= form_for @user do |f| %>
  <%= f.text_field :name %>
  <%= f.submit %>
<% end %>
```
The latter uses builder field helpers, a syntax separate from form_tag.  But as Rails progresses into newer versions both are being phased out in favor of a combination of the two.

form_with

In the future forms in Rails will be exclusively created with form_with, a helper which looks to combine the functionality of form_for and form_tag into a single method.  This in turn creates a bit of extra code on its creation with having to specify the use of a model or not.

In the case of form_with as form_tag
```
<%= form_with url: users_path do |f| %>
  <%= f.text_field :name %>
  <%= f.submit %>
<% end %>
```
…and with form_with accepting a model:
```
<%= form_with model: @user do |f| %>
  <%= f.text_field :name %>
  <%= f.submit %>
<% end %>
```
Personally I am enjoying the switch to form_with & the combination of resources it allows.
The True Guide to True and False in PostgreSQL
Tags: sql, beginners, database, postgres
Published: 2019-10-23 19:21:25

`TRUE`, `FALSE`, and `NULL` are the possible boolean values in PostgreSQL. 

Surprisingly, there are a bunch of different values you can use for `TRUE` and `FALSE` - and one alternative for `NULL`. Also surprisingly, some values you'd expect might work, don't work. 

Let's check out `TRUE` first.

# TRUE
The following literal values evaluate to `TRUE`. Note that case doesn't matter.

`true`
`'t'`
`'tr'`
`'tru'`
`'true'`
`'y'`
`'ye'`
`'yes'`
`'on'`
`'1'`

Other similar options will cause a syntax error, such as `1`, or `tru`.

Now let's look at `FALSE`.

# FALSE
Here are literal values that will evaluate to `FALSE`:

`false` 
`'f'`
`'fa'`
`'fal'`
`'fals'`
`'false'`
`'n'`
`'no'`
`'of'`
`'off'`
`'0'`

Other similar options that throw syntax errors include `0`, `fa`, and `'0.0'`. 

# NULL
`NULL` is the value PostgreSQL uses for *missing value* or *no value*. Note that `NULL` is not equal to any value. `NULL` isn't even equal to itself!

`UNKNOWN` evaluates to `NULL`. Again, capitalization doesn't matter.

There are no string literal values that evaluate to `NULL`. Similar terms throw syntax errors, including `nan`, `none`, and `n`.

# Advice

Stick with `TRUE`, `FALSE`, and `NULL`. As the [docs]((https://www.postgresql.org/docs/12/datatype-boolean.html) state, "The key words TRUE and FALSE are the preferred (SQL-compliant) method for writing Boolean constants in SQL queries." 

Use `WHERE my_column IS NULL` and not `WHERE my_column = NULL` to return the rows with `NULL` values. Remember, `NULL` is not equal to `NULL` in PostgreSQL. 😁

# Code
Here's the code you can use to test different values:

```sql

/* make the table and values*/
CREATE TABLE test1 (a boolean, b text);
INSERT INTO test1 VALUES (TRUE, 'I am true');
INSERT INTO test1 VALUES (FALSE, 'I am false');
INSERT INTO test1 VALUES (NULL, 'I am null');

/* see the data */
SELECT * 
FROM test1;

/* test it out */
SELECT * 
FROM test1
WHERE a = 'true'  
```

You can use `WHERE a =` to compare `TRUE` or `FALSE` booleans, strings, or numbers. 

Comparing a string with `IS` won't work. For example, `WHERE a IS 'true'`, will cause an error.

You must use `=` or `LIKE` to compare string values that you want to evaluate to a boolean. For example `WHERE a = 'true'`. 

However, you need to use `WHERE a IS` to test against `NULL` options. 

Fun! 😉

# Wrap
I hope you found this little guide to be interesting and informative. If you did, please share it on your favorite social media so other folks can find it too. 👏

I write about Python, Data Science, and other fun tech topics. Follow me and join my [Data Awesome mailing list](https://dataawesome.us20.list-manage.com/subscribe?u=b694acf1df58e5bb039ce60a6&id=5da23b7424) if you're in to that stuff.

![Truing a Wheel](https://thepracticaldev.s3.amazonaws.com/i/gf0pg6on21sraojajvaw.jpg)


Happy PostgreSQLing! 👍
[help needed] Rails application upgrade from 3.2 to 5.2
Tags: help
Published: 2019-10-23 19:07:35

---
title:[help needed] Rails application upgrade from 3.2 to 5.2
published: true
description: Help needed for upgrading rails from 3.2 to 5.2
tags: Help
---

We were planning to upgrade my rails application which is a monolith application and having around a million LOC. What would be the best way to upgrade? 

The following are the options 
1) 3.2 -> 5.2 (Separate branch running for a long time, Total mess up)
2) 3.2->4.2 ->5.2 ((Separate branch running for a short time)
3) 3.2->4.0->4.1->4.2->5.0->5.1->5.2(Running in master periodically, But we may need to write code in particular version which may become obsolete in the next coming version)

I am planning to follow approach 3, but I am not sure which part is added in version (4.0 to 5.1) and removed in(4.2 to 5.2).

Did anyone did rails upgrade for their application, what was the approach.

PS: I saw many posts around this, but nothing solid.
A Note of Encouragement
Tags: node, javascript, cli
Published: 2019-10-23 18:57:02

Earlier this year, I set up a new computer for my son. In the process, I created an "Easter Egg" for him to find. I left a note on the desktop with some instructions on how to run a command-line interface (CLI) application I created.

```sh
> heybuddy
```

![Hey buddy, I just want you to know... I know you can do it. Don't give up.](https://thepracticaldev.s3.amazonaws.com/i/tc0ra06rm4u57wk055dh.png)

As I hoped, I'll sometimes walk by and see he has a terminal window open and has run the app several times 😊

The source code for this application is on [GitHub](https://github.com/reverentgeek/notes-of-encouragement-cli). It's written in JavaScript and uses [Node.js](https://nodejs.org). There are instructions in the `readme` on how to customize the messages, change the name of the CLI app itself, and install it on someone's computer.

You can certainly take the idea and create your own customized encouragement CLI app, or take it further to create a web, desktop, or mobile application. Or, how about an encouragement robot!

Use the power of technology to make a positive impact on the people you care about! Let me know if there's anything I can do to help 🙂 Thanks for reading, and I hope you have an awesome day!

![Get out there and be awesome!](https://thepracticaldev.s3.amazonaws.com/i/7kp5sar1lr7p7k714w84.jpg)
My first open source contribution
Tags: opensource
Published: 2019-10-23 18:31:25

---
title: My first open source contribution
published: true
description: 
tags: open-source
---

I am very happy for my first PR merged to master in an open-source project. And the project is **dev.to** web application. Isn't that cool?!?

Many thanks for the team for supporting me, to make this happen 🙏🏻🎉

{% github https://github.com/thepracticaldev/dev.to/pull/3449 %}
You do not need to use the classnames package
Tags: javascript, react
Published: 2019-10-23 19:31:01

---
title: You do not need to use the classnames package
published: true
date: 2019-10-23 18:27:07 UTC
tags: javascript, react
canonical_url: https://www.iamdeveloper.com/posts/you-do-no-need-to-use-the-classnames-package-1bb/
cover_image: https://thepracticaldev.s3.amazonaws.com/i/vxmx385yqbvafn2si5f5.jpg
---

Do not get me wrong, the [classnames](https://www.npmjs.com/package/classnames) package is really handy. It is also quite popular with just over 3.5 million downloads per week as of the date of this blog post. Most React based projects I have worked on use it.

If you are not familiar with the `classnames` package, it allows you to build a set of CSS classes based on some conditionals. Straight from there documentation:

```javascript
classNames('foo', 'bar'); // => 'foo bar'
classNames('foo', { bar: true }); // => 'foo bar'
classNames({ 'foo-bar': true }); // => 'foo-bar'
classNames({ 'foo-bar': false }); // => ''
classNames({ foo: true }, { bar: true }); // => 'foo bar'
classNames({ foo: true, bar: true }); // => 'foo bar'
```

Note: `true` and `false` are used to simplify the example, but normally these would be conditional variables, methods or functions.

Having said that, JavaScript has come a long way and there are features in the language that allow us to do pretty much the same thing, specifically [template strings](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) or as it is also called, template literals.

If you are not familiar with template strings, you can build a string with variables mixed in. Let us look at the previous examples, but this time with template strings.

```javascript
`foo bar` // => 'foo bar', not that exciting
`foo ${ true ? 'bar': '' }`; // => 'foo bar'
`${true ? 'foo-bar': '' }`; // => 'foo-bar'
`${ false ? 'foo-bar' : ''}` // => ''
`${ true? 'foo': '' }, { true ? 'bar': '' }`; // => 'foo bar'
`${ true ? 'foo' : ''} ${ true? 'bar' : '' }`; // => 'foo bar'
```

These are trivial examples, but it is just to show you that you can do pretty much the same thing with template literals. If you want to see this in action, here is an example from my site's source:

{%github https://github.com/nickytonline/iamdeveloper.com %}


```jsx
...
<nav
   className={`navbar is-transparent ${styles.navbar}`}
   role="navigation"
   aria-label="main-navigation"
   data-cy="nav-bar"
>
...
```

[https://github.com/nickytonline/www.iamdeveloper.com/blob/master/src/components/Navbar.tsx#L51](https://github.com/nickytonline/www.iamdeveloper.com/blob/master/src/components/Navbar.tsx#L51)

This is not mind blowing code, but just another way to do it.

Happy coding!

Photo by [David Rotimi](https://unsplash.com/@davidrotimi?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/s/photos/different?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
Automated Dependency Updates
Tags: techtalks, javascript, typescript
Published: 2019-10-23 18:12:24

At [CopenhagenJS](https://copenhagenjs.dk) in August I was able to share my work on [Renovate](https://renovatebot.com/)—a universal dependency update tool—and how you can use it to save time and improve security in software projects.

If you want to find out more about Renovate you can find us [on GitHub](https://github.com/renovatebot/renovate).

{% youtube yAntIlemF28 %}
🎉 Celebrating 2K followers!
Tags: meta, watercooler
Published: 2019-10-23 17:58:34

Wow, the community here on Dev is amazing! I don't even really know what to say, but I just wanted to thank everyone who read my posts and responded.

I assume most of them came from this post, which took off much faster than I ever expected:

{% link https://dev.to/darthostrich/vim-for-people-who-use-visual-studio-code-full-article-1j1c %}
 

Much love.
Tips For Your ResumePortfolioLinkedIn

Tags: webdev
Published: 2019-10-23 17:41:43

Resume
Resumes are the bane to everyone’s existence. Nobody likes writing them, and no employer offers a job solely because of somebody’s resume. So you need to treat it accordingly: A way to get interviews (you will soon see that it’s not the only way). Spend a very little amount of time on your resume (no longer than 1 day). Look at the types of jobs that you want to have, and have the words and characteristics described in these job positions in your resume. Finally, make it personal for each position you apply to so that the employer’s name is on the resume. It will take you 10 seconds, but it already puts you above most people that just send mass amounts of resumes.
LinkedIn
Update your LinkedIn profile with the skills that you have and according to the jobs you are targeting. Recruiters will use LinkedIn to look for candidates and they will always search for users who have recently changed their profiles since this signals to them that this person is looking for a job. Therefore, try and update your LinkedIn profile every two days (this can be as simple as a word change). If you have listed skills that are in demand (i.e. Javascript, Node.js, React) you will have these recruiters messaging you for opportunities daily.
An Alternative To Resumes
The above methods are pretty basic. Let’s start to get creative. Instead of sending your resume, I usually email a company I am interested in working with/ Don’t send a resume, but instead send them your personal website (You can use the sample apps you have built in this course!) and tell them why you want to work at the company. Ask them if you can come by for an interview. You can send this message to the head HR person or someone who is a gatekeeper. Using tools like LinkedIn you will be able to easily find who this person is in the company.
An Event Better Alternative
Message lead developers, or CTOs at companies that you are interested in, and let them know your interest in getting to where they are professional. Ask to take them out for coffee, or come by the office to chat with them about their careers. Never ask them for a job. But in the end, inquire if they have anybody that they recommend you speak to. Really emphasize in this meeting your goal to learn by working amongst smart developers. If they are not looking to hire, they will direct you to someone that is.
The Best Alternative
Message CEOs and ask what technical problems they are having. Tell them what technologies you are an expert in (by this point you should know whether they require people with your skills), and ask to solve a real-life problem that they have free of charge. They can keep the work, and in return, all you ask for in an interview.
Don’t ever just send mass amounts of resumes. Select the jobs that you want, personalize your emails and try to avoid sending a resume. Try to bypass formalities of an application process by getting an interview right away. Most likely during the interview they will ask you for a resume, but by that point, you have already gotten what you needed.
Working with JavaScript objects
Tags: javascript, beginners, tutorial, functional
Published: 2019-10-23 17:25:16

JavaScript arrays are great. There are so many methods and strategies for working with JavaScript arrays. But the exact opposite can be said about JavaScript objects.

That's why, when saw the prompt for the RNA Transcription challenge on [Exercism](https://exercism.io/my/tracks/javascript), it took a few days to get started. I could just tell it would be a JavaScript objects challenge.

```javascript
Given a DNA strand, its transcribed RNA strand is formed by replacing
each nucleotide with its complement:

G -> C
C -> G
T -> A
A -> U
```
My first solution was a little clumsy. When I Googled JavaScript methods, most results focused showcased `Object.keys()` and `Object.values`. My first solution didn't work for a couple of reasons:
1. It was too complicated. With a for...of loop, an object method, a .map() method and an if statement, it was an obviously meek first attempt.
2. My mentor disagreed with using `res` as a default parameter, saying "since res is not really an input, you can declare it inside the function body rather than in its signature"
3. It tried to force the object into array unnecessarily 

```javascript
const transcription = {
  G: "C",
  C: "G",
  T: "A",
  A: "U"
};
export const toRna = (string, res = "") => {
  for (let char of string) {
    Object.entries(transcription).map(([key, value]) => {
      if (key === char) {
        res += value;
      }
    });
  }
  return res;
};
```

This final solution is a lot cleaner:
1. It uses only one .map() method
2. It makes use of bracket notion, rather than forcing the object into an array
3. It uses explicit returns, rather than saving the results to a variable

```javascript
const transcription = {
  G: "C",
  C: "G",
  T: "A",
  A: "U"
};

export const toRna = string => {
  return [...string].map(letter => {
      return transcription[letter];
    })
    .join("");
};
```
This exercise was a great reminder to get more comfortable working with JavaScript objects. One thing with studying alone is that its' easy to get into a comfort zone and stay there. In terms of data structures, my comfort zone is arrays. So I need to resist defaulting to arrays.

If you'd also like a refresher on working objects, check out this [blog post](https://codeburst.io/javascript-quickie-dot-notation-vs-bracket-notation-333641c0f781) on accessing JavaScript object properties .
Website Review From Fellow Developers
Tags: design, discuss
Published: 2019-10-23 17:09:17

Hey Dev.to community! It's awesome to join this community/website. I found it looking for a solution to an issue I was having, and sure enough, there was an answer!

Anyways, I want to start something cool: a website/app review thread. 

If you have a personal project, company website, or other app/web app that you'd love to get feedback on, post it down in the comments! Tell us a little bit about your project, and what you would like feedback on!

Once you've done that, go through the comments and find 1-2 other sites to review and give feedback on.

Let's use our knowledge to help each other!

I'll start us off: here's my portfolio site built using Gatsby and hosted on Netlify. I'd appreciate if you could tell me what you think of the design/user experience!

https://jarodpeachey.netlify.com

Now it's your turn!