teleren/devto huggingface dataset:
Meet DNAI: A ML-Based Analysis of DNA
Tags: dnanalyzer, opensource, ai, bioinformatics
Published: 2023-05-16 16:13:52

Today, we are proud to introduce DNA.I., a groundbreaking open source project that brings the power of machine learning to DNA analysis. DNAnalyzer is the first and only tool that lets you explore, understand, and discover the secrets of your DNA sequences with ease and elegance. DNAnalyzer is built on DNA.I., a revolutionary ML-based framework that can reveal the hidden patterns and properties of DNA sequences, such as gene expression, methylation, transcription factors, and more.

DNA.I. uses cutting-edge deep learning models and techniques to learn from massive genomic data and generate stunning insights. DNA.I. can also do amazing things like sequence alignment, motif discovery, and annotation. DNA.I. is designed to be flexible and modular, so you can tailor your analysis pipelines and integrate your own data sources.

Some of the amazing features of DNAnalyzer v3.0.0-beta.0 are:

* A beautiful and intuitive graphical user interface (GUI) that lets you easily upload your DNA sequences, choose the analysis options, and see the results in gorgeous visualizations.
* A powerful command-line interface (CLI) that gives you more control and functionality for those who love to work in a terminal environment.
* A rich collection of pre-trained models and datasets that cover a wide range of DNA analysis tasks, such as gene expression prediction, methylation detection, transcription factor binding site identification, and more.
* A comprehensive documentation that guides you through how to install, use, and extend DNAnalyzer and DNA.I.
* A community forum where you can connect with other users, ask questions, share feedback, report issues, and contribute to the development of the project.

We believe that DNAnalyzer will be an invaluable and delightful resource for researchers, students, educators, and enthusiasts who want to explore the fascinating world of DNA. We welcome any suggestions, comments, or contributions that can help us make our project better and more accessible and beneficial for everyone.

**To download the new DNAnalyzer, please visit our GitHub repository: https://github.com/VerisimilitudeX/DNAnalyzer/releases**

To learn more about DNA.I. and how it works, please read our upcoming research paper (releasing on 8/31/2023): A ML-Based Analysis of DNA

As always, thank you for your support and interest in DNAnalyzer! 🧬
The 10 Day Ship : Day 3/4 - [NullPointer exception] Fixed #GitHubHack23
Published: 2023-05-16 16:03:53

Here we are , in addition to day2's research, i was looking for ways to do the report I wanted to build.

Found one.

Graph is not supported in Slack.

Found another one.

I need a slack channel to build it. 

Created one.

Now processor working fine.

Sample report is generated.

So, from here onwwards, goes up 🚀 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3xmimfxqb1490xswwfzx.png)
Now that we have ChatGPT, should you still learn Software Development in 2023/24?
Tags: ai, softwareengineering, career, computerscience
Published: 2023-05-16 16:01:38

---
title: Now that we have ChatGPT, should you still learn Software Development in 2023/24?
published: true
description: Is it worth studying the fundamentals of Computer Science and coding in 2023?
tags: artificialintelligence, softwareengineering, careers, computerscience
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-05-16 15:31 +0000
---

My very brief take on this current era is simple: while models like [ChatGPT](https://chat.openai.com/), [Bard](https://bard.google.com/), [Copilot](https://github.com/features/copilot), [CodeWhisperer](https://aws.amazon.com/codewhisperer/) are truly impressive, they still make significant mistakes far too often, and it is likely that this trend will persist for some time. Who will be responsible for identifying and rectifying these errors? Who will be responsible for improving these tools and scaling them for large-scale usage? (Hint: Software engineers). 

As a result, I anticipate that we will encounter numerous bugs in production in the years to come, which, in the future, perhaps the copilots or similar tools will be capable of automatically fixing. However, at the end of the day, I do not believe these tools will ever be able to fully replace the expertise and problem-solving skills of a competent software engineer who possesses a deep understanding of the underlying principles and complexities of software development. 

While AI models like ChatGPT are powerful tools that can augment certain aspects of software development, they are not a substitute for the comprehensive knowledge and skills acquired through formal education and practical experience in software development. In fact, I believe that with the enhanced speed and efficiency provided by these tools, we possess the capability to extend the benefits of AI to a wider audience. As a result, there will be a greater demand for Software Engineers who can leverage these advancements to make this technology accessible to more people.
Connecting a Node Js app to Azure MS-SQL server. Part 1
Tags: azure, cloud
Published: 2023-05-16 15:50:23


![Azure](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p7rdtkvkkbsnscynqq5g.jpg)

So after learning alot about the azure databases options in my cloud school,i wanted to create something cool with them.

Being a developer, i decided to try connecting a nodejs application to a MSSQL database.

So my goal was to see data from my on website.Preferably in a table like this.
![table data](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kc7lct9yeyov48my6wcx.png)

**First** i had to set up an **SQL Database** in Azure which i will focus on in this part.

**Second** i had to create a **nodejs** **application**.I decided to use express.js, typescript and ejs.
![Project Structure](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/1ecb11fmn8q0xw1shn1x.png)

So to get started setting up an SQL database,
Step 1: Search for SQL Database
![Search](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9y59gh0dlw7fe273i8a6.png)

Step 2: Tap the create button at the far left.
![Tap create](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/o325pg6wmatdnk40lx5i.png)

Step 3: Next select a resource group to manages all your resources for the service.

![Resource group](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/psr0wty1cessym1g30ya.png)

Step 4: Now it is time to add a database name and create or choose an SQL server to run the database on.

![Choose server](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cqmwdc5jdvnr0xpbpfxs.png)

Step 5: Creating a server involves giving a name and choosing the authentication option to log into it.
Make sure to keep the credentials for later.


![Server](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ljrbrtz6qx8c96cp2iyi.png)

Step 6: Next select the backup option
![Choose server](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hycy4gu6tuvvjbdydl3u.png)

Step 7: Next we are choosing the network options as below to allow us to connect to the server.
![network](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k7yxf9ol3o97ktbxcukn.png)

Step 8: Next we can leave these as defaults and move to security

![defaults](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c40pezn2pmw1mq4kdvzm.png)

Step 9: Next we shall choose to use a sample database.

![Choose sample](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/za319ynubm6whu7gkpvo.png)

Step 10: Click the create button
![Create](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ckohh6po76suvyxth3s8.png)


Next we shall open microsoft Azure Studio and connect to to the created Database in Part2.
#2665: Counter II
Tags: leetcode, javascript, algorithms
Published: 2023-05-16 15:48:10

Number 3 on the [30 Days](https://leetcode.com/discuss/study-guide/3458761/Open-to-Registration!-30-Days-of-LC-JavaScript-Challenge) Challenge is #2665, Counter II. This challenge is primarily an add-on to the last day, so be sure to check out [my post](https://dev.to/jd2r/2620-counter-1c4p) on #2620 for concept detailing.

## Process
The instructions given are pretty simple.
> Write a function `createCounter`. It should accept an initial integer `init`. It should return an object with three functions.

> The three functions are:

> `increment()` increases the current value by 1 and then returns it.
`decrement()` reduces the current value by 1 and then returns it.
`reset()` sets the current value to init and then returns it.

There are also some straightforward tests included.
```js
const counter = createCounter(5)
counter.increment(); // 6
counter.reset(); // 5
counter.decrement(); // 4
```
We're basically dealing with a glorified version of the previous challenge. All we're gonna do is write it the same way, but with `reset` and `decrement` functions added. Both are simple to implement, but we'll start with what we have.

Let's write a function that has the basic functionality and the `increment` function included in a return object.

```js
function createCounter(init) {
  let i = 0;
  return {
    increment: () => init + ++i
  }
}
```

We declare a private variable `i` and return an object with an `increment` function that increases `i` by 1 and returns the new value.

> But in the last challenge you used `i++`, not `++i`. What's the deal?

It's because in the last problem, we needed the counter to return `init` the first time it was called. For this function, we need it to _always_ return `init` plus an incremented value of `i`. Since `++i` returns the new value, it's just like adding 1 the first time around, 2 the second, etc.

The decrement logic will use an almost identical structure.

```js
function createCounter(init) {
  let i = 0;
  return {
    increment: () => init + ++i,
    decrement: () => init + --i
  }
}
```

This should make sense if you understand that `--i` is the same as `++i`, it just works in the opposite way.

Now we write the `reset` function, which we're told sets the value that will be returned back to `init`. How did we accomplish this the first time? By setting `i` back to 0.

```js
function createCounter(init) {
  let i = 0;
  return {
    increment: () => init + ++i,
    decrement: () => init + --i,
    reset: () => {
      i = 0;
      return init;
    }
  }
}
```

And that's the solution.

## Conclusion.
Incrementing operators can be confusing. Once you learn the cheatsheet for how they work, the solution to the problem begins to make sense.

`i++` - increments `i` then returns `i - 1`
`++i` - increments `i` then returns `i`
`i--` - decrements `i` then returns `i + 1`
`--i` - decrements `i` then returns `i`

If you found this helpful, be sure to leave a 💖 on the post and a ⭐ on the [Github](github.com/jd2r/leetcode) repo!

Follow for more LC content :)
React-laag
Tags: tutorial, react
Published: 2023-05-16 15:37:02


React-laag is a React library for creating layered UIs, such as tooltips, popovers, and dropdowns. It provides a simple API for creating these types of UI elements, and handles positioning and interaction logic for you.

One of the key features of react-laag is its ability to position a layer relative to a trigger element. This allows you to create UI elements that appear 
next to 
or above/below a trigger element, such as a button or link. React-laag also provides a set of hooks and utilities for handling user interactions, such as clicking or hovering over the trigger element.

Here's an example of how react-laag can be used to create a tooltip component:

```
import React from 'react';
import { useLayer, Arrow } from 'react-laag';

const Tooltip = ({ children, content }) => {
  const [isOpen, setOpen] = React.useState(false);
  const { triggerProps, layerProps, arrowProps, renderLayer } = useLayer({
    isOpen,
    onOutsideClick: () => setOpen(false),
    triggerOffset: 8,
    placement: 'top-center',
  });

  return (
    <>
      <span
        onMouseEnter={() => setOpen(true)}
        onMouseLeave={() => setOpen(false)}
        {...triggerProps}
      >
        {children}
      </span>
      {renderLayer(
        <div {...layerProps}>
          <div>{content}</div>
          <Arrow {...arrowProps} />
        </div>
      )}
    </>
  );
};

export default Tooltip;
```
Частный бухгалтер в Москве
Published: 2023-05-16 14:27:02

https://xn----8sbcihe5b2bqgip7a.xn--p1ai/


Алла Семёновна Антохина - востребованный частный бухгалтер, обладающий обширными знаниями и опытом в области бухгалтерии и финансов. Она старательно работает над тем, чтобы упростить финансовую жизнь своих клиентов, обеспечивая им своевременные и точные отчеты, а также качественные бухгалтерские услуги.

Ее сайт, шеф-бухгалтер.рф, является практическим ресурсом для предпринимателей и бухгалтеров, предоставляющим информацию о последних изменениях в законодательстве, новостях и статьях по бухгалтерии. В дополнение к этому, на сайте представлены образовательные материалы и курсы, помогающие бухгалтерам и предпринимателям расширить свои знания и навыки.

Алла Семёновна не только управляет сайтом, но и активно участвует в его наполнении, делясь своими знаниями и опытом с читателями. Она признается своими коллегами и клиентами за ее профессионализм, преданность делу и глубокие знания в области бухгалтерии.

При работе с Аллой Семёновной можно быть уверенным в надежности и качестве предоставляемых услуг. Она всегда готова помочь своим клиентам и делает все возможное, чтобы их бизнес был успешным и процветающим.
#2620: Counter
Tags: leetcode, javascript, algorithms
Published: 2023-05-16 15:23:44

Back again with the second problem in the [30 Days](https://leetcode.com/discuss/study-guide/3458761/Open-to-Registration!-30-Days-of-LC-JavaScript-Challenge) challenge, #2620.

## Process
The instructions read as follows.
> Given an integer `n`, return a `counter` function. This `counter` function initially returns `n` and then returns 1 more than the previous value every subsequent time it is called (`n`, `n + 1`, `n + 2`, etc).

Here's the unit tests, if you're curious about the return values.
```js 
const counter = createCounter(10)
counter() // 10
counter() // 11
counter() // 12
```

Welcome to an important JS concept known as **closures**. Say we have the following function.

```js
function outerFunction() {
  let outerVariable = 'I am outside!';

  function innerFunction() {
    console.log(outerVariable);
  }

  return innerFunction;
}

let closure = outerFunction();
closure(); // Outputs: "I am outside!"
```

Here's the key concept - we're still able to access the `outerVariable` variable even though the function has finished executing. This means that to solve this problem, it's nothing harder than creating a private counter variable and incrementing it every time the function is called.

Let's write some code.

```js
function createCounter(n) {
  let i = -1;
  return function() {
    i++;
    return n + i;
  };
}
```

This was my original solution - but I'm looking back over it realizing that it's pretty messy. Let's try to simplify.

First thing - we don't need the `i++` and `n + i` to be separate bits. I had forgotten that `i++` doesn't just increment `i` - it returns the old value as well (if you want the new value, use `++i`). So let's change that and add some arrow syntax.

```js
function createCounter(n) {
  let i = 0;
  return () => n + i++;
}
```

Note that I changed the initial value of `i` from -1 to 0. This is because originally we had to increment then return the number - the first time it had to be `n`, so we set `i` to -1 knowing that when we called the function the first time it would equal to `n` and not `n + 1`. With `i++`, it'll return `n` the first time - so if we kept `i` at `-1` we'd get `n-1`, which is _not_ the result we want.

## Conclusion
With knowledge of closures, this one isn't that hard. This concept is another one that keeps coming out in the challenges, so make sure you're rock-solid on the concept before moving on.

If you found this helpful, be sure to leave a 💖 on the post and a ⭐ on the [Github](github.com/jd2r/leetcode) repo!

Follow for more LC content :)
Basic Understanding of useState in React
Published: 2023-05-16 15:20:50

Hello and welcome to the second leg of my journey through introductory coding! As you begin to grasp the basic concepts of React there are a few nuances that you must understand. One of these is the react hook useState. 

## What is useState and when do I need it?

useState leverages array destructuring to declare a state variable. A state variable is used when you have values that need to change based on an interaction (ex. forms with value changes, search bars, click events that change, etc.)

First thing is first; you must _call_ useState at the top of each component where you plan to utilize it. You can do this by:

`import {useState} from 'react';`

Then you must declare the state variable as well as its initial state. The initial state will vary based on what kind of value the variable will hold. If the result is boolean then you should set the initial state to a boolean, if it is meant to return an object then you should structure the object as a default, etc. 

Let's say we want to use a state variable for an input that is an age. Thus, we would want the initial state to be a _number_. The basic syntax and the syntax for our purposes is as follows:

Basic:
`const [something, setSomething] = useState(initialState)`
Ours:

```
function myComponent() {

   const [age, setAge] = useState(25);
   const [name, setName] = useState('Eli')}
```

The return value will be an array that has two items; the current state of this item (set to the initial state that I defined) and the _set_ value that lets me change the value based an interaction.

To update our value we need to call the function and update the state:

```
function handleClick () {

   setAge(54)}
```
React will now store my next state, render my component again with age as 54, then update my UI.

I hope this was helpful in gaining a very basic understanding of useState in react. Happy coding!
PostgreSQL: prepared out of order order by
Tags: postgres
Published: 2023-05-16 15:06:01

Recently, a colleague asked me a question about a PostgreSQL construction for which they found that it would silently ignore part of SQL, and whether it's truly doing that.

This is a mini setup that shows the issue:
```
create table test( id int primary key, f1 text );
insert into test select id, chr(ascii('a')+id) from generate_series(25,0,-1) id;;
```
This creates a table 'test' with two fields, and fills the fields with a number and a character from 'z' to 'a'.

If I execute the following SQL:
```
select * from test order by f1 limit 1;
```
I get:
```
postgres=# select * from test order by f1 limit 1;
 id | f1
----+----
  0 | a
(1 row)
```
Here's the issue:
```
prepare prep(text, int) as select * from test order by $1 limit $2;
```
And then execute the prepared statement:
```
postgres=# execute prep('f1',1);
 id | f1
----+----
 25 | z
(1 row)
```
These are two different results for seemingly the same statement. I actually didn't need to do anything, they also found the issue:

For the statement, the execution plan is:
```
postgres=# explain select * from test order by f1 limit 1;
                           QUERY PLAN
-----------------------------------------------------------------
 Limit  (cost=1.39..1.39 rows=1 width=6)
   ->  Sort  (cost=1.39..1.46 rows=26 width=6)
         Sort Key: f1
         ->  Seq Scan on test  (cost=0.00..1.26 rows=26 width=6)
(4 rows)
```
- The select performs an unfiltered scan of a field for which is no index, and thus it performs a seq scan.
- Because the seq scan does not hold ordering guarantees that an ascending or descending index can, it has to perform a sort for the order by.
- The limit rowsource then takes one value because of limit 1.

For the prepared statement the execution plan is:
```
postgres=# explain execute prep('f1',1);
                         QUERY PLAN
------------------------------------------------------------
 Limit  (cost=0.00..0.15 rows=3 width=38)
   ->  Seq Scan on test  (cost=0.00..1.26 rows=26 width=38)
(2 rows)
```
- The select performs an unfiltered scan of a field for which there is no index, and thus it performs a seq scan.
- Limit does take the first value.
- The sort step is missing, and thus the first value that it found from the seq scan is shown, which is 'z', but could be anything, because the seq scan does not guarantee ordering.

I also found some sources on the internet explaining that this is because of the bind parameters, probably the best one being  from the PostgreSQL mail list: https://www.postgresql.org/message-id/1421875206968-5834948.post@n5.nabble.com

The essence of that explanation is that for the order by the parameter is used as an identifier, whilst parameters are values, and that therefore this doesn't work. However, what I am puzzled about is why this succeeds in creating a prepared statement, and why it all works, but silently skips the order by.

I hope to hear any opinions or reasons for ignoring it, or from things missing from this small investigation.
#2667: Create Hello World Function
Tags: leetcode, javascript, algorithms
Published: 2023-05-16 15:03:39

In response to the recently created [30 Days of JS challenge](https://leetcode.com/discuss/study-guide/3458761/Open-to-Registration!-30-Days-of-LC-JavaScript-Challenge) on LeetCode, I'll be putting out my own solutions to each problem and working through a solving strategy while I'm at it.

The first challenge posted was #2667 - a problem involving a simple  function-inside-function trick. Let's take a look.

## Process

A brief set of instructions are given.
> Write a function `createHelloWorld`. It should return a new function that always returns `"Hello World"`.

The thing I'm liking about this particular set of problems chosen for the challenge is that the majority of them have unit tests that have already been written, giving us a guideline to shoot for.

Here's the test created for this problem.

```js
const f = createHelloWorld();
f(); // "Hello World"
```

So we'll obviously start by making the createHelloWorld function, and following that we'll put another function in it that will be the return value for the first.

```js
function createHelloWorld() {
  return function() { return "Hello World" }
}
```

Note that this is ES5 syntax, using arrow functions is another option and can be done more simply by far because the function we're returning happens to be an anonymous function - a fantastic example of where we can use an arrow to shorten the code.

```js
const createHelloWorld = () => () => "Hello World";
```

## Conclusion

In three lines or one, this is a simple problem with a simple solution. The most important takeaway from this problem is that we can return functions from inside of functions - a critical feature that we're going to be using a lot in the coming challenges.

If you found this helpful, be sure to leave a 💖 on the post and a ⭐ on the [Github repo](github.com/jD2R/leetcode)!

Follow for more LC content :)