teleren/devto huggingface dataset:
How To Train Your Technical Recruiter
Tags: career, beginners, job, hiring
Published: 2023-06-28 19:54:06

In an ideal world, all of the [jobs](https://www.stoutsystems.com/jobs/) coming your way from your Technical Recruiter would be an exact match to your skill set, salary desires, career aspirations, and geography. But let's face it, in many instances that's simply not the case. So, if you're suffering from Job Description Mismatch Syndrome, then it may be time to train your recruiter.

## Step 1
Ensure that your recruiter is up to date with your particulars. If it has been awhile since you've had a conversation, they may not be aware that you've moved on to new technologies, or that your salary has increased significantly since your last job search.

## Step 2
When you receive a job description that's an obvious mismatch, take a moment to let your recruiter know why this one is not such a good fit. A good recruiter will add that information to your profile to ensure that future reach-outs are as targeted as possible.

## Step 3
If there have been some changes in your situation since you last interacted with your recruiters, send them an updated [resume](https://www.stoutsystems.com/resume-writing-for-technology-professionals/) so they can familiarize themselves with what you are now doing.

## Step 4
Take a moment to update your [LinkedIn](https://www.linkedin.com/company/stout-systems/?lipi=urn%3Ali%3Apage%3Ad_flagship3_pulse_read%3B3C2zuhMfRwmq8NNFhEaEjg%3D%3D) profile and send the URL to your recruiter. More and more, LinkedIn has become recruiters' go-to source for up-to-date information on prospective candidates.

Even if you aren't currently in the market for a new job, it never hurts to maintain a relationship with a "well-trained" recruiter. At the very least, it allows you to keep your finger on the pulse of what's happening in the [job market](https://www.stoutsystems.com/tech-workforce-hiring-trends-june-2023/) for people with your skill set and experience level. In a worse-case scenario, it keeps you in a better position in the event that things take an unexpected and bad turn in your job situation.

If you follow these steps, you’ll have a mutually beneficial relationship with your recruiter. If you're looking for a job in the tech industry, [visit our job board](https://www.stoutsystems.com/jobs) to see if you qualify for some of our positions.

_Enjoyed our Getting Hired article? [Sign up](https://www.stoutsystems.com/signup/) to receive a monthly article in your inbox!_

_[Stout Systems](https://www.stoutsystems.com/) is the software consulting and staffing company Fueled by the Most Powerful Technology Available: Human Intelligence®. We were founded in 1993 and are based in Ann Arbor, Michigan. We have clients across the U.S. in domains including engineering, scientific, manufacturing, education, marketing, entertainment, small business and robotics. We provide expert level software, Web and embedded systems development consulting and staffing services along with direct-hire technical recruiting and placements._
Injectable Factory Method with Spring Boot
Tags: java, spring, designpatterns, springboot
Published: 2023-06-28 19:50:51

The Factory Design Pattern meets Dependency Injection 🏭+💉

{% embed https://youtu.be/WNzjz0v0t7o %}

In software engineering, the Factory pattern is a creational pattern that creates objects without exposing the creation logic to the client and refers to newly created objects using a common interface. In other words, it encapsulates object creation and decouples it from the client code that uses the objects. This can improve code maintainability, flexibility, and reusability.

For example, imagine you have a program that needs to create different types of objects, such as shapes or vehicles. You could write a bunch of conditional statements or switch statements in your client code to determine which concrete class to instantiate. However, this approach can quickly become messy and hard to extend. Instead, you could use a factory method or a factory class that takes care of the object creation based on some input parameter or logic.

Some benefits of using the Factory pattern include:
👉 Encapsulating object creation and reducing coupling
👉 Providing a central point of control and configuration for object creation
👉 Promoting the open-closed principle by allowing new subclasses to be added without modifying existing code
👉 Enabling testing and mocking of the client code without actually instantiating real objects

Dependency injection takes the factory method to the next level. Dependency injection is a programming technique that makes a class independent of its dependencies. It achieves that by decoupling the usage of an object from its creation. This helps you to follow SOLID’s dependency inversion and single responsibility principles.
Injectable Factory Method in .NET
Tags: dotnet, csharp, designpatterns
Published: 2023-06-28 19:42:28

🚀 Do you know how to make a factory method injectable in .NET? 🏭

{% embed https://youtu.be/uFitprS7k1g %}

Discover the powerful combination of dependency injection and the factory pattern in .NET! By leveraging these two concepts, you can achieve even greater flexibility and loose coupling between components.

🏭 The factory pattern allows you to create objects without exposing the creation logic to the client code, and refer to newly created objects using a common interface. The factory pattern is a key enabler in creating applications that comply with the open-closed principle.

🔗 Dependency Injection promotes loose coupling by injecting dependencies into classes, rather than having them directly create or manage their dependencies. This enables easier testing, flexibility, and maintainability of your codebase.
AGE Contribution Guide
Tags: postgres, apacheage, postgressql
Published: 2023-06-28 19:31:27

In the previous blog we wrote `add_two_numbers` function implementation.


file name is `add_numbers.c`
```c
#include "postgres.h"
#include <string.h>
#include "fmgr.h"

PG_MODULE_MAGIC;

PG_FUNCTION_INFO_V1(add_one);

Datum
add_two_numbers(PG_FUNCTION_ARGS)
{
    int32   arg1 = PG_GETARG_INT32(0);
    int32   arg2 = PG_GETARG_INT32(1);

    PG_RETURN_INT32(arg1 + arg2);
}

```

Now, let's add this function to age.
save the file in the following path: `src/backend/commands`

then add the next line to makefile on the top directory of the project
`src/backend/commands/add_numbers.o`
add this line in OBJS section.

Add the signature to the age--1.3.0.sql at the end of the file
```sql

CREATE FUNCTION ag_catalog.add_numbers()
RETURNS Integer
LANGUAGE c
AS 'MODULE_PATHNAME';
```
then run the following commands in the project directory
```bash
sudo make clean PG_CONFIG=/usr/local/pgsql/bin/pg_config
sudo make PG_CONFIG=/usr/local/pgsql/bin/pg_config
sudo make install PG_CONFIG=/usr/local/pgsql/bin/pg_config
```

Now we are done, after running the postgres server you can use this function as follows
```sql
select * from ag_catalog.add_numbers(2,3);
```

[apache age github repo](https://github.com/apache/age)
[Create a Custom Function in Postgres](https://dev.to/ahmedmohamed/create-custom-function-in-postgres-bjc)
Create a Custom Function in Postgres
Tags: postgres, apacheage, database
Published: 2023-06-28 19:03:27

User-defined functions can be written in C language. Such functions are compiled into dynamically loadable objects.


## function implementation in c

The version-1 calling convention relies on macros to suppress most of the complexity of passing arguments and results. the declaration of a version-1 function will be as follows 
```c
Datum funcname(PG_FUNCTION_ARGS)
```
before that we will add the macro call
```c
PG_FUNCTION_INFO_V1(funcname);
```
to declare the function name

then the function implementation of adding two numbers will be as follows.
```c
#include "postgres.h"
#include <string.h>
#include "fmgr.h"

PG_MODULE_MAGIC;

PG_FUNCTION_INFO_V1(add_one);

Datum
add_two_numbers(PG_FUNCTION_ARGS)
{
    int32   arg1 = PG_GETARG_INT32(0);
    int32   arg2 = PG_GETARG_INT32(1);

    PG_RETURN_INT32(arg1 + arg2);
}

```

notice that `PG_RETURN_xxx` or `PG_GETARG_xxx`
where `xxx` refer to the variable datatype

then, we could define the functions to PostgreSQL with commands like this
```sql
CREATE FUNCTION add_one(integer) 
RETURNS integer
AS 'DIRECTORY/funcs', 'add_two_numbers'
LANGUAGE C;
```

Ref:
[postgresql documentation](https://www.postgresql.org/docs/current/extend.html)
My First 3D project - FPS TIME TRIAL
Tags: unity3d, beginners, development, gamedev
Published: 2023-06-28 18:58:27

Boom Boom Barrel is an unfinished project created using Unity. It is a time trial FPS with 3D modeling and animations based on free assets. The goal is to destroy the barrels before time runs out and the whole stage explodes. It has a burst damage system, so you have to keep your distance. In short, it is a green project to which new levels could be added, even with enemies instead of objects. 

I would like to know what formation you recommend to learn how to create enemies with AI.


{% embed https://www.youtube.com/watch?v=LyR-2SWiVLg %}
How to Add CSS to your HTML Pages
Tags: html, css, webdev, beginners
Published: 2023-06-28 18:57:21

> ##Read the full article [here](https://discover.hubpages.com/technology/how-to-add-css-to-html):

---

In this article, we'll discuss three methods to add or link CSS to an HTML document:

- Inline styles
- The style tag
- External stylesheets

## Inline Styles

Inline styles in HTML allow you to apply custom CSS styling rules directly to elements within an HTML document. 
To apply inline styles, you need to add the style attribute to the HTML element you wish to style. The style attribute should contain one or more CSS property-value pairs enclosed within curly braces. Below is an example:

```html
<h2 style="color: red; font-size: 24px;">Hello World</h2>
```

## Style Tag

Another common way of adding CSS to your document is using the style tag. The Style tag in HTML allows you to define CSS rules directly inside an HTML document (usually the head of the markup). This method is common when working on single page website where there is less styling needed.

```html
<!DOCTYPE html>
<html>
   <head>
      <title>Style Tag Example</title>
      <style>
         h1 {
            color: blue;
            font-size: 36px;
         }
      </style>
   </head>
   <body>
      <h1>This is a Heading</h1>
      <p>This is a paragraph.</p>
   </body>
</html>
```

One significant advantage of using the Style tag is that you can define specific styles for different media types. For example, you can define different styles for printing, screen, or mobile views.

## External Stylesheets

An external stylesheet is a separate CSS file that is linked to an HTML document using the link tag. This file typically has a `.css` extension and contains the style rules for the entire website. Here's an example:

```html
<!DOCTYPE html>
<html>
   <head>
      <title>External Stylesheet Example</title>
      <link rel="stylesheet" href="style.css">
   </head>
   <body>
      <h1>This is a Heading</h1>
      <p>This is a paragraph.</p>
   </body>
</html>
```

In the example above, the link tag is used to point to style.css, which is a separate file that contains CSS rules for the website. However, keep in mind the inline styles have the highest priority so they will override the stylesheet.

---

Check out this post [here](https://discover.hubpages.com/technology/how-to-add-css-to-html).
Also, have a look at my [blog](https://salehmubashar.com/blog).
Thanks!
What is an SDK for a REST API?
Tags: api, programming, learning, python
Published: 2023-06-28 18:56:50

Hi DEV!

I wrote an article about what an SDK is for a REST API and wanted to share it here https://konfigthis.com/blog/what-is-an-sdk.

SDKs make the experience of integrating REST APIs 10x better and I break down exactly why in this article with code samples. 

_FYI the article contains cool animations and code snippets that I think you guys would like!_
{% embed https://www.youtube.com/watch?v=1DZtxbIqFEY %}
How To Add A New Column In An Existing Table Using MySQL
Tags: database, mysql, beginners, tutorial
Published: 2023-06-28 18:28:14

For adding a column (attribute) to an existing table, we use the `MODIFY` statement in MySQL.


For example, suppose that I have a table named student. The **student** table contains 3 columns (attributes) named name, id and cgpa. Now I want to add one more column named phone_number there.

Then the MySQL command would be:

```sql
ALTER TABLE student ADD phone_number VARCHAR(12);
```

Now let me explain each keyword. As I want to alter a table that is already been created, I used the `ALTER` keyword. Then the question comes which thing I want to alter; is it a table or database or anything else? The answer is I want to alter a particular table.

Therefore I used `ALTER TABLE`. A database can have multiple tables in it. I need to spcify the exact table where I want to make the alteration. Therefore, I stated the table name there. Then comes the part exactly which type of alteration I want to apply.

As I want to add a new column, I have stated that in my command. Then I stated my new attribute (column) name and the data type with it.

After finishing the statement, I used a semicolon to specify that the statement is finished.

That is how the query command works!

### 📹 If you are comfortable with a step by step video tutorial, then I have already created one video for all of you!

{% embed https://youtu.be/tEjQEwhcaqM %}

If you want to follow me then you can follow me on [Twitter](https://twitter.com/Fahim_FBA) and [GitHub](https://github.com/FahimFBA).
Also, make sure to endorse me on relevant skills in [LinkedIn](https://www.linkedin.com/in/fahimfba/).

If you like to watch programming related content regularly, then check out my [YouTube channel](https://www.youtube.com/@FahimAmin?sub_confirmation=1).

Have a good day! 😊

Cover: Photo by <a href="https://unsplash.com/@casparrubin?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Caspar Camille Rubin</a> on <a href="https://unsplash.com/s/photos/mysql?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
Help Needed!
Published: 2023-06-28 18:27:59

Hi, I'm new to GitHub and I'm studying Laravel php as me and my friend are building an app together, I'm wondering if any of you fine coders have any tips when it comes to "React" ?

were learning from the ground up and want any cool links or info that make learning React fun? 

whats your best thing about react? whats good to know?
who's smashing it in the dev areas and whats stood out about React over other frameworks.

any good repositories' out there?


thanks in advance!

Craig Bird
Need an advice about dashboard creating
Tags: react, community, dashboard, admin
Published: 2023-06-28 18:26:37

We do outsourced development, so we often start new projects. We do not work with off-the-shelf CMS - all on frameworks from scratch, usually PHP, node.js we have on the backend. These projects constantly need to create a control panel. 

In 90% of cases it is rather monotonous tables and forms. The process of creating them becomes a chore. In the other 10% there are also complex tasks, which need to be implemented in the control panel: special interfaces, logic. 

We know that there are different solutions, but perhaps you have had experience and can advise something specific. As you have understood, we need a tool so that we can rivet the same type of admin panel, but if necessary, create custom solutions.
Power of Generics
Tags: typescript, advanced, webdev, programming
Published: 2023-06-28 18:20:25

Today I want to discuss very shortly about one such use case of generics. Nowadays everyone want to leverage the usecase of typescript. A quick introduction about generics also would be better to begin with.



## What are Generics in Typescript ?
From my point of view , _generic is something an alias for a data type which would be unknown_. According to google, by definition

> Generics are code templates that you can define and reuse throughout your codebase. They provide a way to tell functions, classes, or interfaces what type you want to use when you call it.

Lets say you have a function

```typescript
function helper(param:string):string {
  return param;
}
```
Here you can see you are passing a string as a parameter which is denoted by `param:string` and return type is string which is denoted by `():string`. 

let's say you have a situation that you don't know what data would come here as a parameter and the same data type you are gonna return .

This is where generics are useful. You can type your function as

```typescript
function helper<T>(param:T):T {
  return param;
}
```
Now this function knows your data type and assigns your same data type as return.
In my View
```typescript
function helper<UnknownDataType>(param:UnknownDataType):UnknownDataType {
  return param;
}
```
I think you have an understanding about generics. Lets dive into the use case.

We have a situation that you should allow all the strings and selective strings. For example, 

You should allow the user to enter size as 'L' and 'XL' means

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mcjhtcdgmqtxx4w6nrjt.png)

this compiler giving me options as L and XL as an autoComplete.But if I type other string it will give error.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7xf9lp5klclu8hu0s7zx.png)

We can do like this
```typescript
type Size = 'L' | 'XL' | string;
```
But compiler loosing the autoComplete for 'L' and 'XL' and at the same time _Size_ is becoming string data type.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hivnm5ldwjfz9isec1c6.png)

here is the solution
```typescript
type Size = 'L' | 'XL' | Omit<string, 'L' | 'XL'>
```
Now you can see compiler giving me the auto-complete for L and XL

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y5gyt77djadjw18lf9xz.png)

Also it didn't complain when I give other string

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hjo1vk0zwtkmnabkd01r.png)

Lets put this in generic way
```typescript
type Selective<T extends string> = T | Omit<string,T>
```
Now the code is like
```typescript
type Selective<T extends string> = T | Omit<string,T>

type Size = Selective<'L' | 'XL'>

function makeShirts(i:Size) {
  return 'hello'
}

makeShirts('XS')
```

Adios. Love Coding. Give it a thumbsup if you like it. Thanks.
خدمة تغليف الهدايا
Published: 2023-06-28 18:10:57

إذا كنت تبحث عن طريقة فريدة وشخصية لتغليف
[الهدايا](https://sensaaa.com/category/nOpND
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lx9dmvx8bzcpupwlryfr.jpeg)) متجر سينسا خيارك الأمثل و الأسهل
عند رغبتك بتغليف أي منتج أضف عدد المنتجات
“Hope is not a strategy for success”
Tags: beginners, community
Published: 2023-06-28 18:01:14

“Hope is not a strategy for success” - Doug Durham

This quote came out of my attendance at the Kansas City Developers Conference (KCDC), my first ever in person Dev conference. 

Although I’ve attended several fantastic virtual conferences this year, there was something unique and wonderful about physically sitting in a room filled with like minded people. I attended so many engaging talks, most especially the talk on Go and another on Technical Writing which I (having a degree in Creative Writing) adored.

But to go back to the quote above. When the speaker first shared it during the conference I felt like it encapsulated my journey towards becoming an Engineer perfectly. For years I had wanted to get into the technical side of startups, and the higher I rose in Client Success the harder it became to switch careers and make my hope a reality.

But one day something clicked. I’d been teaching myself JavaScript for months when I had a moment of clarity. If I didn’t make the decision to leave and go back to school, I wasn’t sure I ever would. So I did. And for the last two years I’ve been working towards an Associates in Computer Science. 

This last Spring I took a semester off to attend a Web Development Bootcamp and found I loved Python, React, and Redux. When I graduated, I was in the final stages of interviewing for an internship located in Chicago, which sadly ended up being canceled just as I was accepted.

From there I brushed myself off and realized I was unique in being a digital nomad and a travel hacker. So why not go to conferences and spend my unemployed time traveling and meeting people? 

Thus after receiving a generous student scholarship and using up my Alaska Airlines miles that had been sitting there collecting dust, I was able to attend my first conference, KCDC. 

“Hope is not a strategy for success” has stuck with me ever since. I like to think of it as a gentle reminder to not get lost in the doom scrolling of cold-applications and to put myself outside my comfort zone more. 

So a big thank you to KCDC for being a wonderful first in-person conference experience. I couldn't have asked for a better one!
Disabling TLS in ArgoCD server
Tags: argo, tls, tutorial
Published: 2023-06-28 18:04:42

Hi everyone,

Recently, I started using ArgoCD, and I encountered some issues while configuring it with Ingress nginx. For instance, I faced errors related to TLS, which resulted in many redirects. To resolve this problem, it was necessary to disable TLS in the ArgoCD server.

For disable, edit the configmap `argocd-cmd-params-cm` and add `server.insecure: "true"`

## Example

```sh
apiVersion: v1
data:
  server.insecure: "true"
kind: ConfigMap
metadata:
  ...
```

## Restarting deployment

It's necessary to restart the deployment to apply the configuration

```sh
kubectl rollout restart deployment argocd-server -n argocd
```
Quickly testing an extension from docker image
Tags: yugabytedb, postgres, distributed, sql
Published: 2023-06-28 18:00:27

In this series about PostgreSQL extensions on YugabyteDB here is a way to test quickly an extension by taking its files from a docker image. This is what I did to test Apache AGE.

The following starts a container from an image with PostgreSQL and the extension we want, and extract them into a tarball (I take files with pattern `age*` as I know those are the files from Apache AGE extension):
```sh
docker run --rm -i apache/age bash -c '
mkdir -p stage/share/extension stage/lib 
mv $(pg_config --pkglibdir)/age* stage/lib
mv $(pg_config --sharedir)/extension/age* stage/share/extension
tar -C stage -zcvf - lib share
' > age.tgz
```

I start YugabyteDB with the extension files extracted in the right place, and test a CREATE EXTENSION:

```sh
docker run --rm -i yugabytedb/yugabyte bash -c '
cd $YB_HOME/postgres
tar --skip-old-files -zxvf -
yugabyted start --advertise_address=0.0.0.0
until $YB_HOME/postgres/bin/pg_isready ; do sleep 1 ; done | uniq
ysqlsh -e <<SQL
create extension age;
SQL
' < age.tgz
```

In this case, it fails immediately because OIDs are not supported yet:
```
Starting yugabyted...
/tmp:5433 - accepting connections
create extension age;
ERROR:  OIDs are not supported for user tables.
```

It would have been a waste of time to compile the extension. Getting the files from a RPM or Docker image is the fastest way to quickly check the CREATE EXTENSION.

This is also a good example to show that not all extensions are immediately compatible with YugabyteDB. When it deals with the storage that is specific to PostgreSQL (and OID is an internal object identifier) it may require some modifications. Doing it depends on the roadmap priorities but open source contributions are welcome.