fabiochiu/medium-articles huggingface dataset:
What is React Router and How to use it?
By: Yunus Fırat
Tags: Web Development, React Router, Backend Development, Software Development, Front End Development

React is component-based, meaning that the different parts of a React application are broken down into smaller components and then organized inside higher-level components. Even though our react-driven application comprises multiple components and we don’t necessarily display all of these components to our user.

For instance, we’ve created a simple react application that contains three different components namely countries-list component, country component, and search component.

When the user clicks on a country from the countries list, only a country component is visible to him and the rest of the components are hidden from him or her and the details about a country are displayed to him.

To get this job done, we’ll make use of routing. To use routing in our react app, we have to install all the routing-related packages. In this case, we’ll use React-Router which is a very well-known library to implement routing in our react.js app.

How to Use It?

First step: npm install react-router-dom ( make sure you have installed the react-router )

Second Step: Import necessary hooks to create routes for your application.

Third Step: Make sure you wrap your code with Router.

As you above the first Navbar has been added just after the Router tag and it is not inside the switch which means the Navbar component will remain even if we change the route.

just after the navbar you see that I have created a switch and fill inside with Route.

NextStep: The first route is like our home page and I have put the Search and Countries Component inside.

As soon as we open localhost:3000 we will see Navbar, search, and countries component.

Next Step: Let’s say when we are home page, we would like to click one country from the countries list then we have to create a link like above to go to the country/country.name page.

if you check the second path path=”/country/:name”

we say that go to country component with a param which is :name.

Last Step:

we are now at country Component and all we need is to learn the name! what exactly the user clicked?

the easiest way to access the param is you should get match as props which is an object and then access the match.params.name.

in my case here, I filtered my array according to param and show a single country on the browser. Please have a look at the completed project below.

Click here.

Thank you

Yunus
My experience with OUTBOX
By: Tra Jan
Tags: Freelancers, Full Stack Developer, Web Development, Backend Development, Front End Development

My experience with OUTBOX

my web development path

I am by the names of TRAJAN MUKALAZI, and two years ago i developed a dream of making websites and web apps but did not know how to go over it. I could try on my own to learn and could grasp a few concepts and fail on the others since i had no mentor. It was really a hard time.

Until i saw OUTBOX EDU expired advert on twitter. I hopefully followed for any opportunities and failed to get any until i went to the OUTBOX offices in kampala where i was sent to Jaelle. The first time i talked to Jaelle was really awesoe because i got hope and it never fell back.

I joined EDU learning which has happened for about two weeks and am really grateful. Though there are some challenges with keeping in class in time and a few other things, I am glad for the opportunity and new energies reload everyday to keep it following.

OUTBOX EDU learning paved the way and now i see where am heading in the web development career path. Nothing is pulling me back because i gotta go to new heights everyday. Hardwork and consistence keeps me going everyday and i will get there.

The OUTBOX team is really great one and am glad i was granted an opportunity to reach extra ordinary levels with such a team. They are really passionate about what theu do as they teach and instruct us through the skill up sessions.

The passion they input surely spreads to the learners and i personally never want to miss any skill up session. I believe this PREP VII will yield alot of good to me and it will be really viisible in the near future as long as I believe and keep working at it.

I have been able to find out that web development is not a simple journey for i have experienced alot of frustrations while learning most especially during self learning. There is alot of failing, disappointments, distractions and the urge to quit.

All of these frustrations have been carried away by OUTBOX and i greatly appreciate the push they have given me in improving and learning web development. Though i have focused on only front end development, I am hoping OUTBOX will take me to Full stack development.
5 Frontend Problems You Shouldn’t Ignore
By: Miloš Živković
Tags: JavaScript, Backend Development, Software Development, Front End Development, Programming

Frontend development is hardcore

Integration of API is a challenge. You need to handle errors, do load balancing, and mock the API for testing. This poses a challenge, but frontend has its challenges as well.

What can be challenging on the frontend? They need to consume the API you built, what’s the problem there? State management, reactive frontend, and correct presentation in the end. The frontend can bring harder obstacles than the backend.

Senior frontend developer at my company says:

“It’s easier to become senior backend developer than senior frontend developer.”

Why it’s easier to become a senior backend developer? There are a lot of devices you need to develop for. Not to mention the dreaded Internet Explorer. Constant changes — constant learning. Constant learning will always make you lag behind the senior backend developers.

The backend is more important. Why is the backend more important? Consequences. You won’t get fired if the margin is off by 2px. You’ll get fired if the margin is off by a few thousand dollars. Backend deals with different problems. Problems frontend developers don’t have.

Backend problems can put the site out of business. Frontend problems may put the site out of business. Even so, both are necessary.
GraphQL vs React Server Components — Do We Need Both?
By: Fernando Doglio
Tags: React, Reactive Programming, Backend Development, Front End Development, Programming

Why Would You Want to Use Server Components?

Server components are a fantastic new tool, still under development, but that already shows a lot of potential benefits.

Let’s quickly go over — what I think — are the main reasons why you’d want to use server components on your future projects:

They simplify communication between front-end and back-end code.

This is true to the point where you no longer need to think about that communication. All you have to do is consider how components are connected.

This is achieved by leveraging the Context component. They’ve added a location object inside the context, which all client components are subscribed to (this seems to be done automatically by one of their unstable functions).

When the location changes based on a user action, the following code is triggered:

Full code can be seen here

They allow you to break the client-server waterfall

One of the major motivations for creating these components was the use case when you have nested components, all fetching information from the back-end.

In this scenario, only once the parent component receives the data, are the children capable of starting their request. And the same happens if these children have children of their own. This effectively creates a waterfall that is heavily penalized by the potential latency between client and server.

By using server components, we limit that latency to the time the server requires to access the external data source. We still have the same roundtrip there, but at a lower cost.

They provide a more cohesive and easier to maintain codebase with a smaller bundle size

This point is major for big applications. Right now, the bundle size is a potential problem for the user if they are behind a slow internet connection. However, depending on your use case, that size can be highly reduced if you were to move all data-fetching operations to the back-end, including their dependencies.

As I’ve already mentioned, server components are never downloaded to the client, and the same goes for their dependencies. This means the final bundle size is considerably smaller. This is also achieved by simplifying the code abstractions used, and logically grouping data-fetching code (server components) on one side, and user-interacting code (client components) on another one.

They provide full access to Node.js back-end API

For back-end related code, this is a major win. You automatically gain the ability to use libraries such as Sequelize, Mongoose and other ORMs (to give you an example) directly in your React code.

You can also use Node’s IO API directly, and to help you with this, the React team is also building ReactIO, a thin wrapper around Node’s I/O API to help you even further.
Get yourself a better Django proxy experience
By: Niccolò Mineo
Tags: Django, Backend Development, Proxy Pattern

Ah, Django proxy models and the power they hold! Yet, the implementation aftermath can highlight a number of unwanted side-effects. Here’s a couple of tips when working with Django proxies that will make end-users grateful and developers sigh in relief.

No more toe-curling results from ORM queries

Initialize discriminating proxy model fields to their expected values. You’ll see the benefits of this tip when unit-testing proxy instances already, where you should be using bulk_create() to speed up your tests and straight proxy model queries to shorten your ORM statements.

Start with overriding the main queryset method in managers.py :

from django.db.models import manager

class ParentProxyModelManager(manager.Manager):

"""The parent proxy model manager.""" def get_queryset(self):

"""Return the queryset."""

return super().get_queryset().filter(

discriminating_field=self.model.DISCRIMINATING_FIELD

)

In models.py :

from django.db import Model

class ParentModel(models.Model):

"""The parent model.""" # Add your proxy-discriminating field(s) here

class ParentProxyModel(ParentModel):

"""The parent proxy model.""" DISCRIMINATING_FIELD = None objects = ParentProxyModelManager()



class Meta:

"""Model options."""



proxy = True



def __init__(self, *args, **kwargs):

"""Initialize proxy instance."""

super().__init__(*args, **kwargs)

self.discriminating_field = self.DISCRIMINATING_FIELD

Sensible link behaviour in the parent changelist

Sometimes you want to keep showing the proxy parent model admin for listing all the results. One issue with this is that every instance link in the changelist still points to its non-proxified version. You will see how problematic this ends up being if not corrected as your proxy modeladmins grow in behavioral diversity. What we can do is add a method to our model returning the right proxy and override change_view() in the proxy parent admin model.

In models.py :

from django.db import Model class ParentModel(models.Model):

"""The parent model.""" ... def get_proxy_model(self):

"""Return the proxy model."""

# Check those fields' values discriminating your proxy model

# and return the latter

In admin.py :

from django.contrib import admin

from django.http import HttpResponseRedirect @admin.register(ParentModel)

class ParentModelAdmin(admin.ModelAdmin):

"""The parent model admin.""" fields = ("discriminating_field",) def change_view(

self,

request,

object_id,

form_url="",

extra_context=None

):

"""Return the change view."""

if self.model.__name__ == "ParentModel":

obj = self.get_object(request, object_id)

proxy = obj.get_proxy_model()

if proxy._meta.model.__name__ != "Operation":

redirect_url = reverse(

(

f"admin:{proxy._meta.app_label}_"

f"{proxy._meta.model_name}_change"

),

kwargs={"object_id": obj.pk},

)

return HttpResponseRedirect(redirect_url)

return super().change_view(

request, object_id, form_url, extra_context

)

As you can see, it doesn’t take that much to make Django proxy models better. Find here the official documentation on the general subject.
Introduction to Node JS
By: Tharindu D Sandeepa
Tags: Nodejs, Tutorial, Web Development, Backend Development, JavaScript

Node JS is a JavaScript runtime environment built on Google Chrome’s JavaScript V8 engine. Node JS is a very popular open source cross platform around the world. Some people think Node JS is a framework and plenty of others think it is a programming language. But it is not a framework or a language. Node JS is a just runtime environment but it allows you to use JavaScript as a language.

Why Node JS is popular?

Node JS is popular among developers. Because Node JS allow you to do frontend and backend development using just one language(JavaScript). Initially JavaScript is a just client side language. But after with Node JS developers able to use JavaScript as server side scripting language.

Developers can develop single page applications, real time apps, API’s, social media apps, data streaming applications by using Node JS.

Getting Started with Node JS

If you want to start scripting with Node JS, first you should download and install Node JS and there should a text editor on your computer. Node JS is open source and completely free software and You can easily download latest version of it.

After the installing, you can execute a file on Node JS and verify the installation.

Create a file named app.js using text editor on your computer write following code.

Now open command prompt(Windows) or terminal(Mac) and run the code using Node JS.

If Node JS is installed properly output like below.

If not working change the directory to which app.js file located. If still not working then you should install again the Node JS properly.

First Application using Node JS

Before creating an application using Node JS, let’s see what are components of a Node JS application.

Import required modules- Load Node JS modules by using ‘require’ directive. Create server- create a server which react client’s requests Read the request and return- Server will read the HTTP request and return the response

Import required modules

We create a variable named “http” and load http module to that variable by using “require” directive.

Create server

You should create a server by using calling http.createServer() method and then we bind it at port 8081 with using listen() method. Pass it a function with parameters request and response. Write sample code to show output always “First Application-Node JS”.

After saving the code run the code.

With that output, it’s verify the server has started. Server running at http://127.0.0.1:8081/ in your computer as a local host.

Make a request to the local Node JS server.

Type this server address(http://127.0.0.1:8081/) any browser and see the results.

Now You make your first HTTP server and you done the first Node JS application successfully.
What is BaaS and Serverless Backend?
Tags: Baas, Backend Development, Serverless

Let’s discuss the importance of the backend and its applications first. The backend handles server, application, and the database, the three significant aspects of any project. If you consider a registration form, the front end involves UI elements that allow you to provide the relevant data in the fields.

(Image Source- https://blog.back4app.com/baas-vs-serverless/)

The information provided through the application is stored in the database, which is responsible for data processing. The server located in a different location retracts the data from the database. The interconnectivity between these three essential elements ensures the proper functionality of an application.

Why Should Developers Focus on Backend?

Organizations prefer to deploy the websites and applications in various environments as per their requirements. Cloud deployment, web server hosting, and seamless operations are essential aspects for companies. The varied hosting environments enable developers to use backend customization for their websites.

Backend holds the complete responsibility of information exchange. Any user providing or accessing data from the application required hiccup-free backend functionality. The information submitted by the user will be stored using backend code. Hence backend coding plays a crucial role in information exchange in the business.

The user experience of any website will depict the image of the company. The quality of the backend code is one of the significant reasons that ensure website functionalities work flawlessly. The backend code is also responsible, which makes websites vulnerable to security attacks.

Role of Serverless Backend (BaaS Vs Serverless Computing)

(BaaS)Backend as a service is a cloud service model that allows developers to concentrate on writing the frontend application code. Using APIs and SDKs, developers can integrate all the backend functionalities without building the backend.

BaaS vendors offer predefined software for actions implemented on servers, such as user authentication, database management, remote updating, push notifications, and cloud storage and hosting. Serverless computing and BaaS are similar in terms of serverless performance but have significant operational differences.

From construction to code execution, here are differences between true serverless architecture. Serverless applications are broken down into functions and perform the actions only after each function responds to events. In the Baas, server-side functionalities are constructed and provided to the developers.

Serverless architecture runs only when each function is triggered by an individual event. These serverless functions are robust and can run from anywhere as long as the application is communicating. The BaaS approach is not event-driven, as they require more server resources, and running code is dependent on the provider.

Our ScriptBees offers application development services of various cloud platforms, and our core team members ensure your applications meet business values, modern standards and provide seamless services.
Generic ViewSets — Serializer Context and Hooks
By: Caronex Labs
Tags: Web Development, Django, Backend Development, Rest Api, Django Rest Framework

Hey there! This article is a part of a series on Django Rest Framework for people who already have experience using the framework. However, you do not need any prior context to understand this article. There are some prerequisites about Django Rest Framework itself that you must know, and I will list them out shortly.

This time, I want to address a problem that you may not face too often. When you do come across it though, it can be a little frustrating to resolve. The problem is, passing context to a serializer. Context in this context (:-p) is just some data that you may want to pass on to a serializer.

Like always, here is a list of prerequisites you will need to know about to fully appreciate the article:

Generic ViewSets — You can read up the docs here or our article on the topic here.

Custom Mixins — Again, docs here and our article on the topic here.

Model Serializers — You can read about it in the docs here.

Abstract User — This fantastic article by SimpleIsBetterThanComplex explains it best.

Knowing what you’re building makes things clearer, so let me lay the situation out. In the articles before this, we cloned the possible API behind Mediums own Profile Page. In this article however, we will be considering story creation to make the need for passing context more apparent.

Here is the current situation

The user has already filled the story in and is waiting to save the story. When he/she saves the story, a post request with all the data is sent to our API and we are responsible for saving the story under the user who sent the request.

Seems straightforward right…
Seed MongoDB using external API in Node.js
By: Barak Saidoff
Tags: Nodejs, Backend Development, JavaScript, API, Mongodb

Now well create our seed file. Let's just call it seed.js. We’ll import the model that we just created above into our seed file, as well as our database connection and the node-fetch API.

const mongoose = require("mongoose");

const SkateSpot = require("./models/SkateSpot");

const db = require("./config/keys").mongoURI;

const fetch = require("node-fetch"); let resultData;

let saveCounter = 0; mongoose.connect(db)

.then(() => console.log("mongodb connection success"))

.catch(error => console.log(error)); const url = ['https://data.cityofnewyork.us/resource/pvvr-75zk.json'] url.map(async url => { try{

const response = await fetch(url);

const json = await response.json();

resultData = [...json]; for (let i = 0; i < resultData.length; i++) { let skateSpot = new SkateSpot({

name: resultData[i].name,

description: resultData[i].status,

location: { coordinates: [resultData[i].polygon.coordinates[0][0][1] , resultData[i].polygon.coordinates[0][0][0]]}

}) skateSpot.save(() => {

console.log("saved" + skateSpot)



saveCounter++;



if (saveCounter === resultData.length) { mongoose.disconnect()

.then(() => console.log("saved succesfully and mongodb disconnected"))

.catch(error => console.log(error)); }

});

} } catch (error) {

console.log(error);

} })

First and foremost, we’ll want to connect to our database in this file to make sure that we can create new documents. Once connected, we’ll define a variable for a counter, and also for our URL which we want to fetch from (it’s an array of URLs just in case later we wanna add more external APIs to fetch from). Then well map the array and fetch to the API which will return a response as an array of objects.

Next, a for loop will map the response array of objects, and for each object, create an instance of our SkateSpot model. We’ll save the park name as our name, park status as our description, and coordinates at position [0][0][1] and [0][0][0] as our locations’ coordinates. After each iteration, SAVE our mongoose object to our Database and increase the saveCounter variable. If our saveCounter is equal to the length of the array of results, DISCONNECT from the database.
5 Useful Commands that you can plug in your next PostgreSQL Query
By: Shahnaz Shariff
Tags: Postgres, Database, Sql, Backend Development, Programming

1. Merging records using Union & Union All

We all know how ‘union’ works. The concept is similar to how it’s in set theory. Adding a union between two queries will result in a distinct set of records.

UNION will remove all duplicates that exists in the result of both queries whereas UNION ALL merges the records from the queries

Union All is faster than Union since no extra time is spent in processing duplicates.

2. Transforming rows into columns using FILTER

More often than not we run into a situation where row values need to be used as column names.

To transform data and display it in several columns, FILTER can be used. Let’s see the below example.

Item Qty Type

------------ ---------- -------------

desk 5 domestic

bat 10 imported

table 15 domestic

table 25 imported

desk domestic

In order to show the total quantity by ‘item’ and ‘type’ from the table, use FILTER!

Query:

Result:

desk_from_domestic bat_from_domestic

------------------------- -------------------------

5 10

3. Returning non-null values using COALESCE

In order to return non-null values from PostgreSQL functions even when the data in tables actually contain null values, use COALESCE function — it returns the first non-null argument passed to it.

Normal Query

SELECT qty * 10 from purchases

Result:

Result

----------

50

100

150

250

null

The same query with COALESCE:

SELECT COALESCE(qty,0) * 10 as result from purchases

Values in the qty field containing null values will now be zeroes. Performing mathematical operations on these values are now possible!

Result:

Result

----------

50

100

150

250

0

4. Debugging functions using RAISE NOTICE

Are you one of those developers who rely on console.log or print for debugging functions?

If yes, RAISE NOTICE will do just the same for you in PostgreSQL and it’s pretty handy!

raise notice 'quantity: %', quantity;

5. Working with dates using EXTRACT

Wondering how to perform regex-like operations on dates?

EXTRACT can be used to get the day, month, year, hour, etc. from a field containing timestamp or date.

SELECT EXTRACT(DAY FROM TO_DATE(final_date, 'YYYY-MM-DD')) INTO final_day;

Final Notes

All of these commands except for RAISE NOTICE works in SQL as well. Working on complex SQL queries and functions can be daunting but knowing these commands will make you feel like coding in SQL is not so hard after all :)
Node.js Beginner Guide-Serving Static File.
By: Arpit Jain
Tags: Nodejs, Web Development, Backend Development, JavaScript, Expressjs

We already are done with Server Setup in the previous post, now today we are going to learn how to load an HTML page with CSS.

First of all, we need to create an HTML page.

<!DOCTYPE html>

<html lang="en">

<head>

<meta charset="UTF-8">

<meta name="viewport" content="width=device-width, initial-scale=1.0">

<link href ="/public/style.css" rel="stylesheet" type = "text/css">

<title>Document</title>

</head>

<body>

<p>Hello, I'm Back</p>

<div class="myblock">

<p>Successfully served Static file!!</p>

</div>

</body>

</html>

A very basic boilerplate, as this is not a UI guide so don’t expect any Awesome UI. Notice I already linked my CSS file. My CSS file is under a folder named “public”, down the line I’ll talk about it.

Below is my CSS file.

.myblock{

display: block;

height: 150px;

width:150px;

padding:30px;

margin: auto;

background-color: greenyellow;

font-size: large;

font-style: italic;

align-items: center;

}

We have the HTML and CSS file ready, now let’s connect it to the express server to serve this HTML file.

var express = require('express')

var app = express()

app.get('/',function(req, res){

res.sendFile(__dirname + "/index.html"); })

app.listen(3000,'127.0.0.1')

*NOTE** I used “__dirname” which is used to indicate the current directory and concatenating it with the index.html file that we had created just a few lines above.

Now let's run!

We did it but it seems like our CSS is not loaded. But why?

Let’s resolve this issue. Due to security issues these static files are not loaded directly, they need to be loaded through some middleware. Middleware is just a simple function you can say or something between the request and response. For eg-

app.get('/',function(req, res) //This function is a Middleware

{

res.sendFile(__dirname + "/index.html");

})

Similarly, we can use express middleware “express.static()”. Now we are going to store our CSS file in the folder named “public” and serve that public folder. The reason behind this is that what if we want to upload images, files, and many more we don't want to write the same logic again and again. So storing any image, file in the public folder can catch up with everything that we need.

So Let’s add this middleware in the code.

var express = require('express')

var app = express()

app.use('/public',express.static('public'));

app.get('/',function(req, res){

res.sendFile(__dirname + "/index.html");

})

app.listen(3000,'127.0.0.1')

This is how we use express middleware to serve static files.

*NOTE** in the function, the first argument is the location of the folder which is storing the CSS file and second argument to load the static file( simply that folder name).

Let’s run again-

Browser View

We did it!!

For more information on how to serve the static file without the help of express, you can follow this documentation https://nodejs.org/en/knowledge/HTTP/servers/how-to-serve-static-files/

I’ll be posting more new content about Node.js. Please Give feedback!
Extending or customizing laravel core bindings
By: Varun Pujari
Tags: Laravel, Web Development, Laravel Framework, Backend Development, Software Development

Photo by Dan Magatti on Unsplash

Do you wonder how laravel hands over the request to you when you type-hint the Request in controller argument. It’s can do this because the request instance is bound in app container with key request . In the same way there are other things like auth , response etc which are bound in the app container.

In this post we will look at how we can extend laravel core bindings and add custom method on core AuthManager class.

Whenever you use auth() helper function or Auth facade. What laravel does is it pulls out AuthManager from service container with key auth and hands over to us.

Now, let’s extends the core AuthManager and add a isAdmin function to it which determines if the current user is admin or not.

If you remember macros from this post, you might be thinking why not add a marco to Auth . Unfortunately we cannot do that because AuthManager doesn’t use Macroable trait. It has it’s own implementation of __call magic method to call non existing methods on auth driver.

Before we start lets add isAdmin function to User modal which will tell us if that user is admin or not.

public function isAdmin() {

return $this->id == 1;

}

For example purpose we will make a user admin if his id is 1. In real, what you should do instead is check if user has a admin role or something like that.

Now, Let’s create a Auth folder in app and then create AuthManager.php file. Paste the below code in it.

AuthManger.php

First, we receive auth and app in our constructor arguments. Assign the auth instance to member variable auth and invoke the parent constructor passing app .

And finally add our isAdmin method which check if user is logged in and call isAdmin on user.

Extending

Everything is setup, the only thing left to do is tell laravel to use our custom AuthManager instead of core one. We will do that is register method of AuthServiceProvider

public function register(){ $this->app->extend('auth', function($auth, $app) {



return new \App\Auth\AuthManager($auth, $app); });

}

Let’s test

We’ll test this in 3 cases.

When user is not logged in.

When admin user is logged in.

When non-admin user is logged in.

I assume that you have database setup and seeded some data in users table

Here are our tests

Run tests

We run the tests

We get green

I hope you got to learn something new today. Feel free to reach out me for any questions.

Thank you.
MY LAUNCHPAD TO TECH…
By: Edidiong Attat
Tags: Personal Development, Tech, Internships, Backend Development

As a girl in STEM, I believe possession of at least one technical skill is a prerogative for me. Lately, I’ve found myself at a crossroads as regards the direction I want my life to go. I recently crossed paths with Afro Tech girls, a non-governmental organization charged with fostering the growth of femmes in technology. That interaction sparked a light in me, one that makes me yearn to be tech-savvy.

I applied for the Zuri internship early this year and unfortunately (or fortunately) I was placed on a waiting list. I woke up to an Email from Zuri on Thursday with a link to join the Ingressve4good slack space. It has been a whirlwind of emotions and feelings since I joined that space, it's a lot. I intend to make use of the fast driven environment and the abundance of networking opportunities to serve as a launchpad into the world of software development.

I am aiming at pushing myself hard enough to remain focused on the goal of gaining at least one technical skill this year. I chose back end development because of the support system in place in my locale which would further amp my motivation to gain this skill. I am also excited about laying down the bone work of an appealing functional site.

Here are some YouTube videos I’ll be bingeing on to make this journey less of an awe.

Figma

2. GIT

3. PYTHON

I intend to make the best of this opportunity to emerge with a satisfactory amount of knowledge and hands-on experience in the world of backend development as well as a certain level of character development at the end of 8 weeks. It is a challenge to me as a person, yeah, it's that deep.

If you're interested in learning more about Zuri and their work, you can check them out on https://zuri.team.

This post will serve as my accountability partner. Here's to Edidiong taking this bull by the horns.
My Zuri Expectations.
By: Michael Madumere
Tags: Web Development, Backend Development, Training

The next phase of my career has kicked off with the commencement of the HNGi8 internship program. I enrolled into the backend web development stack using Nodejs.

I have been a frontend developer for close to two years now and I believe that I am ready for the next challenges that awaits me as a developer. I want to share my goals and expectations at the end of the HNGi8 program and also share some learning materials that could help any aspiring developer or designer kick start their journey.

I was part of the finalists in startng training last year, as well as the HNGi7 internship, but I was unable to move past the second stage because of a job I got during the internship. However, I have had the opportunity to keep learning and growing as a frontend developer and the journey has been challenging.

Now, my goal is to expand my knowledge and skills as a frontend developer and also learn backend development using Nodejs. I also want to gain more experience working in a large team and collaborating on a particular task to ensure that the team goals are achieved. My third goal in HNGi8 internship is to be one of the finalists of this program.

These are some learning materials that helped get more knowledge as a frontend developer last year, I hope you find some of them useful.
MY HNG JOURNEY BEGINS HERE.
By: Chukwudi Marvis
Tags: Python Programming, Beginner Coding, Backend Development, Hnginternship

Picking up the python programming language is quite easy due to the large pool of resources available on the internet and specifically those designed for beginners. You can click here to check out tutorials on python, there are abundant resources on platforms like Udemy, Udacity and Youtube.

A github account is also very necessary when starting out as programmer in order to ease the learning curve. There are also numerous beginners friendly tutorials that will succintly explain what Git is all about and you can access one by clicking here.

Another necessary knowledge that will make the backend journey interesting is the knowledge of design, this is not only limited to designers or individuals interested in UI/UX. Figma is a powerful tool that has come to stay in the design world and a good grasp of the in’s and out of this software is a great plus for any backend developer, just like every othe tools/programming language there are also resources that can put you through figma.

Learning is always fun and I’m looking forward to have lots of it!
GOALS ON ZURI INTERNSHIP (FRONT END /BACK END DEVELOPER)
By: Anuoluwapo David
Tags: Front End Development, Internship Program, Backend Development, Zuri Training

My name is Anuoluwapo David. I am a beginner in this phase and developed an interest in tech with no idea on how to go about it. Luckily, I met a friend who has been in the industry for over a year and who introduced me to this program as my starting point and hopefully this will turn out to be a breakthrough for me in zeal to to learn and develop skills which would be useful and create value. Hence, I joined the Zuri Internship Program following reasons highlighted below

To gain experience and increase marketability — This will give me an edge over candidates while applying for jobs I get to see experience in different roles played at a team level and also gain a better perspective as I get involved in various tasks.

To have a better understanding and specialisation in a particular area of interest — this offer gives me the opportunity to learn and develop skills and new things about the tech industry. This will enable me to learn new skills and tools and put them to practice without pressure.

Networking — this build my professional network and provides me the chance and great environment to meet professionals in this field. Communicate and interact with people of likewise mind to boost my knowledge and connection

To build my confidence as I gain knowledge in certain areas of backend and front end development which will boost my personal growth

Build my resume

Links to Zuri Internship

1. https://zuri.team

2. https://internship.zuri.team

3. https://training.zuri.team

Tutorials for Beginners

1. Figma

https://www.youtube.com/watch?v=g6rQFP9zCAM

2. Github

https://www.youtube.com/watch?v=RGOj5yH7evk

3. Programming Language

Back-end Developer — Python

https://www.youtube.com/watch?v=rfscVS0vtbw

Front-end Developer — ReactJs

https://www.codecademy.com/learn/react-101
An Intern muses over the HNGi8 × I4G Internship (Zuri Internship)
By: Emeka Ihedilionye
Tags: Python, Python Programming, Web Development, Internships, Backend Development

Hi there!

Ever heard of The Zuri Internship? Sounding strange? Lol, relax, its a regeneration of the popular HNG internship you might be familiar it. The eight edition is currently ongoing and is a partnership between HNG and Ingressive for Good (I4G), a community on a mission to create and increase the earning power of tech talents in Africa by training 1,000,000 youths and connecting 5,000 to jobs. This internship has now been rebranded to The Zuri Internship. You can find out more about The Zuri Team and other trainings available.

I am pleased to be part of the cohort for this glamorous internship which will run for 8 weeks. I have opted for the back end track with python as my major stack. I hope that at the end of the internship, I would have gained sufficient knowledge and experience to become a proficient back end developer with python. I also hope to have a better grasp of programming with Go and PHP as well as an adequate overview of DevOps.

Looking forward to this great tech journey. It is a win-win situation anyway but may the best win.

Please find attached are links that you may find useful:

Learn Design with Figma

The beginner’s guide to Git & GitHub - freeCodeCamp

The Best Way to Learn Python – Python Programming Tutorial for Beginners
FIRST ARTICLE ON HNG 8.0 INTERNSHIP 2021.
By: Nwaeze Joshua
Tags: Backend Development, Hngi8 X I4g

I have always wanted to be a proficient Software Engineer. It’s not my first time going into backend development, my lack of understanding and exposure didn’t let me see server side scripting for what it was. It was largely due to not having the right materials to develop myself.

Overtime, I got to understand and see backend scripting, for what it was. It’s what makes technology come alive. In this article, I would share with you; my goals and what I want to achieve by the end of the HNGi8 internship (an eight weeks program).

I NTRODUCTION

My name is Nwaeze Joshua, I am from the southern part of Nigeria precisely Delta State. I am a full stack web developer, I was an intern on the just concluded Zuri/i4G training, I must say it was an amazing experience. It greatly increased my proficiency level, and knowledge in server-side scripting (backend development) with Php. To know more about Zuri team please visit the links below for more information.

Visit https://internship.zuri.team to enroll and learn more about the internship.

https://training.zuri.team to enroll and be part of the training version.

https://zuri.team you could visit this link to learn more about Zuri training.

Below are links to my accounts as well;

GitHub: https://github.com/Joshclone

Figma Profile: https://figma.com/@Joshclone

Feel free to connect and collaborate with me am looking forward to that.

GOALS

I want to develop and increase my proficiency level, learn how to develop applications that can solve real-life problems. This is the major impact of technology, using it to solve and provide solutions to real life situations.

In addition, I wish to build a network and a team after this internship, it is my dream to have my own start-up tech company and bring out my own innovations, that will solve a need for mankind

Furthermore, I want to learn, relearn become an expert meet people with similar mindset and goal during this internship, I believe that to be a major step towards my dreams.

I believe I would gain real life experience during this internship, and much more improve my resume.

WHAT I WANT TO ACHIEVE

At the end of this eight weeks’ internship, it is my goal to boost my confidence level in building and creating software products. I intend being an effective team player, able to provide solutions to hard things, greatly improve my communication skills, build an amazing portfolio.

CONCLUSION

The following are resources that would be of help should you wish to go down this career part as a Backend-server side scripting.

You wish to explore, here are links to beginners learning resources.

GitHub tutorial link

Github and Github for beginners

Figma:

Figma Tutorials for Beginners

PHP:

PHP tutorial link:

Thanks for reading, you can reach me on my twitter handle, and LinkedIn account.

Twitter

LinkedIn
Hire Backend Developers in Germany
By: Khushbu Muchhadiya
Tags: Hire Backend Developer, Backend Development, Backend, Backend Developer, Back End Development

Backend development refers to writing code that runs on servers and handles data processing and storage that happens behind the scenes of websites or apps. Backend developers deal with servers, databases, APIs, etc. They build the logic that sends appropriate information in response to users’ actions in the program’s interface.

Hire efficient Backend developers who are logic and coding experts to execute the functionality of your applications. Our Backend developers at HourlyDeveloper.io are database designing experts and have a vast knowledge of modern programming languages.

A back-end developer is responsible for scripting data, building, and coding/decoding a website. Our developers primarily work with PHP, one of the most popular languages used to power the web. All the formatting, fonts, headings, and colors of the page you’re currently reading are displaying on the front-end. The coding and decoding processes in the server have extracted this information from a database.

Why you should choose us for Back-end development:

We never believe in any project as someone else’s, we work on a project as if it’s our own.

We are a one-stop-shop kind of development Company, providing you with everything to help your business succeed in the marketplace.

We develop each project with utmost scalability and usability in mind to enhance the customer experience.

If you want to create a web application for your business then we provide the best web developers for you to hire. This hiring process at HourlyDeveloper.io is very flexible and we provide some of the best talents out there when it comes to back-end web development. Hire back-end developers from us, and let them lead your way to success.
Assembling Game Backend Services With AccelByte Augment
By: Accelbyte Inc
Tags: Gamedev, Cloud Services, Game Development, Backend Development, Product Updates

Written by Farid Amin Ridwanto

Assembling your own game backend with our wide range of services is easier with AccelByte Augment. Augment lets you create a custom logic to connect, combine and extend the services of your choice to build your best customer-facing game platform.

So how does AccelByte Augment work?

You can hook logic to events fired by any services and call into internal or external APIs. You can also call your custom logic via URL to get data to and from the game client easily and efficiently.

All our services are connected to the monitor function status. With Augment, you can monitor the function statistics such as see how many time a service is fired, the average execution time, the last call timestamp, the logs, etc. via our Admin Portal’s intuitive dashboard.

Function List in Admin Portal Dashboard

Function Configurations in Admin Portal Dashboard

We leverage Kubeless’ runtime functionality

With Augment , we make it possible for you to write custom logic in different languages (Golang, Java, .NET, Python, Ruby, PHP, or NodeJS)

, we make it possible for you to write custom logic in different languages (Golang, Java, .NET, Python, Ruby, PHP, or NodeJS) You can utilize Augment to put all games logic in the cloud so all that the game client need to update is the graphics. To paraphrase it, you only need to update your game logic once and our backend helps you distribute it to your game client in all platforms.

There is no one-size-fits-all solution when it comes to game backend. We let you write your custom logic to extend and combine our services in the best ways possible. Use the language you’re familiar with and we’ll take care of the rest.

Contact us at hello@accelbyte.io for more information regarding our services.
Dynamic Data Source Routing in Spring Boot using AbstractRoutingDataSource
By: Attyuttam Saha
Tags: Multiple Datasources, Spring Boot, Awesome, Backend Development, Spring Data Jpa

1. The Maven Dependencies

2. The Project Structure:

Spring boot project structure

3. The Employee Entity

4. The Employee Repository

5. The Employee Service

6. The application.properties file

7. The Configuration file for the first data source

8. The Configuration file for the second data source

9. The Context

The context file is represented as an enum which serves as the lookup key for a data source.

10. The Context Holder

The context holder is a component that serves as a store for the thread bound context. There are member methods which can be used to set, retrieve and delete the context.

11. The Component responsible for routing to the appropriate DataSource

In this we create two methods:

dataSourceTwoDataSource() dataSourceOneDataSource()

These two methods creates an object of DataSource type containing the configurations of the first and second datasource respectively. These methods are then used to set the list of target data sources to which the application can route to during run time.

The initialization of the target datasources are done in the constructor so that the target data sources are listed when the component is created. The listing is done using the setTargetDataSources() method which takes in a map of data source key to the DataSource object.

12. The Data Source Configuration

The DataSourceConfig file creates a DataSource bean which essentially returns the DataSourceRouting component that we had created earlier. It is due to this exact reason, we have added a @DependsOn annotation which ensures that the configuration bean is created once our routing DataSource is created.

13. The Controller

In the controller I am taking the context as a path variable and then using the context holder to set the current data source context.

14. Running the application

The runner class:

Once the application starts running,

To check the details of the first data source, go to http://localhost:8081/getEmployeeDetails/DATASOURCE_ONE

To check the details of the second data source, go to http://localhost:8081/getEmployeeDetails/DATASOURCE_TWO

Conclusion

So, I have tried to explain the use case and how we will be using AbstractRoutingDataSource provided by Spring to elegantly solve the problem. You can go through the entire article and understand the nook and crannies on how it works and do comment if there are parts which you are confused about.

The code can be found here.