DEV Community: Alphaexcel

AI Won't Replace Developers, But It Will Change How We Work

Alphaexcel — Wed, 25 Mar 2026 00:03:52 +0000

Lately, there’s been a growing fear in the software engineering world.

You see it everywhere:

developers on forums
people learning to code
tech conversations online

The questions are always the same:

Will AI replace developers?
Is it still worth learning programming?
Are we too late to the industry?

Honestly, I understand why people feel this way.

AI tools today can:

generate code
debug errors
explain complex concepts
write documentation
scaffold entire project structures

That’s a big shift.

And yes, there have been moments where I’ve used AI and thought:

"This is doing in seconds what would have taken me much longer."

That can feel intimidating at first.

But instead of seeing it as a threat, I’ve started seeing it differently — as a way to grow faster.

💡 Code Generation Is Not Software Engineering

One major misunderstanding in the AI discussion is this:

People assume that generating code equals software engineering.

It doesn’t.

Software engineering involves:

understanding problems
designing solutions
making architectural decisions
thinking about scalability
communicating with teams
maintaining systems over time

AI can generate output.

But developers provide judgment.

And that difference matters.

⚙️ Where AI Actually Helps Developers

Instead of replacing developers, AI is starting to act more like a productivity multiplier.

Here are some real ways developers are using AI right now:

generating boilerplate code
debugging faster
learning new frameworks
understanding unfamiliar codebases
exploring different solutions quickly

This doesn’t remove developers.

It removes friction.

⚠️ The Real Risk Developers Should Think About

The real risk isn’t AI.

The real risk is refusing to adapt.

Tech has always evolved:

new frameworks appear
tools improve
workflows change

AI is just another shift — but a faster one.

Developers who learn how to use AI effectively will likely become more productive.

Developers who ignore it completely may struggle to keep up.

👨‍💻 My Perspective as Someone Growing in Tech

As someone still growing in tech, I’ve decided not to see AI as competition.

Instead, I see it as:

a learning accelerator
a productivity tool
and sometimes a debugging partner

And there have been moments where I’ve used AI and thought:

"This is doing in seconds what would have taken me much longer."

That can feel intimidating.

But instead of seeing that as a threat, I’m choosing to see it as an opportunity to grow faster.

But I also know something important:

If you rely on AI without understanding the fundamentals, it will eventually show.

That’s why I’m focusing on:

core programming concepts
problem-solving
system thinking
and learning how to use AI wisely

🚀 The Future of Developers

AI will definitely change software development.

But I don’t think it eliminates developers.

Instead, it changes what makes a developer valuable.

In the future, strong developers may need:

better problem-solving
better judgment
better understanding of systems
and the ability to work with intelligent tools

Honestly, that’s not something I fear.

That’s something I want to grow into.

🔚 Final Thought

AI isn’t the enemy of developers.

It’s a tool.

And like every powerful tool, the real difference will come from how developers choose to use it.

Because the developers who will thrive are not the ones who resist change the hardest, but the ones who learn how to work with it.

What's your take on AI in development?

Do you see it as a threat, a tool, or something in between?

Automated Diaspora Data Broker for African Exports

Alphaexcel — Sun, 06 Jul 2025 16:18:28 +0000

🛠️ What I Built

Automated Diaspora Data Broker for African Exports

An AI-powered data agent using Runner H to uncover weekly product demand insights from diaspora communities across the globe — helping small African exporters make smarter decisions and connect directly with active buyers.

This AI agent finds trending products, unmet diaspora needs, and untapped export opportunities using public social data, compiles everything into a structured Google Sheet, and gives actionable weekly recommendations.

Watch the automation in
action:

⚙️ How I Used Runner H

I created a multi-step prompt for Runner H that does the following:

Research diaspora conversations on platforms like Reddit, Twitter/X, and Facebook groups using keywords like:
- “Buy African food”
- “Where to order shea butter”
- “I miss Ankara fabric in Germany”
Analyze for patterns:
- Top requested African products
- Most mentioned countries and cities
- Challenges in sourcing or buying
Output a structured Google Sheet with:
- Trending Products tab
- Market Opportunities tab
- Weekly Recommendation tab
Summarize findings in 5 simple bullet points exporters can act on.

The prompt runs weekly and serves as an automated research assistant for African SMEs and solopreneurs.

🌍 Use Case & Impact

Real-World Problem

Small-scale exporters across Africa often struggle to:

Identify what diaspora consumers truly want
Know where to target for demand
Find time or tools to research effectively

Who This Helps

African entrepreneurs shipping local goods (e.g., snacks, fashion, cosmetics)
Diaspora-focused vendors selling online from the UK, US, or EU
Export marketers and trade promotion agencies

How This Helps

Saves time and money doing market research
Empowers smarter, data-backed exports
Opens pathways to new markets and unmet needs

❤️ Social Love

I’m participating in the Community Champion prize too!

I’ve shared my project on Twitter/X and LinkedIn — please check it out, engage, and share to help spread the vision for African SME empowerment through AI!

🔗 [https://x.com/oyinemi/status/1941894145439649816?t=87TNhIQ_JNnrzWCJbVtLwA&s=19]

Thanks for reading — I hope this inspires other entrepreneurs to use AI tools like Runner H for real-world impact! 🇳🇬✨

Let’s build smarter, export better, and connect global markets through data + creativity.

ANGULAR COMPONENT LIFECYCLE HOOK METHODS YOU SHOULD KNOW

Alphaexcel — Tue, 18 Oct 2022 15:52:17 +0000

First, let’s break down the two major words here which are “Lifecycle” and “Hook”.
• Lifecycle encompasses the stages that the component
undergoes from its creation to its destruction which would
mean death when we talk about a living organism.
• Hook categorizes the different breakpoints that the
component passes through from when it was created.
*

*WHAT IS THE ANGULAR LIFECYCLE HOOK**

A component instance has a lifecycle hook that starts when Angular instantiates a component class the minute you create an application and renders the component view along with its child views.
A lifecycle continues with change detection, that is a change occurs that is also part of the lifecycle of a component.
It updates both views and the component instances as needed as it checks to see what data-bound properties change.
The lifecycle ends when Angular destroys the component instance and it removes the rendered templates from the DOM.
You can check more on the DOM https://medium.com/@ojigbareoyinemi2/dynamics-of-a-basic-counter-javascript-project-5690426a86da
NB: Directives can also have lifecycle hooks.
This is a list of lifecycle hooks in Angular:
• ngOnChange()
• ngOnInit()
• ngDocheck()
• ngAfterContentInit()
• ngAfterContentChecked()
• ngAfterViewInit()
• ngAfterViewChecked()
• ngOnDestroy()

You need to know these three life cycle methods out of the eight:
• ngOnChange() **: This occurs whenever anything on a
component changes this lifecycle method is called or used.
• **ngOnInit(): This is the most commonly used lifecycle
method it is present immediately after you create the
application on angular CLI.
Whenever we load any component the constructor is called next then the ngOnInit() is called.
Constructor: A constructor is basically a part of a class.
What happens when you create a component using Angular is it initiates a class, then when a class is initiated then the constructor is called after those properties are added then the constructor is called after the properties are added then the view is loaded. Then when this process is completed and the constructor is ready to mount, then the ngOnInit lifecycle is created. This ngOnInit means when the component is ready to be mounted on the HTML of the DOM. That’s why it’s called after the constructor.
• ngOnDestroy(): This helps repeated instances or loops
in the component lifecycle to be ended easily. When this
component lifecycle is called or used.

Conclusion

You may not necessarily use all of this Angular component lifecycle hook but the three explained will be essential for your daily usage as you build applications using angular framework.
Happy Coding.

How to fetch data from the backend for primeng drop down

Alphaexcel — Sun, 02 Oct 2022 03:31:05 +0000

When using components in primeng depending on the framework of your choice which may be angular or react or some other framework. We will be discussing today, using the primeng component to fetch data from the backend.
What you need to know about using the primeng component is you need to go to their documentation using this url:www.primefaces.org/primeng/dropdown, this link takes you straight to the dropdown component.
then you install primeng to your application using the following command.



npm install primeng --save
npm install primeicons --save

once they have been installed successfully you would see the following imports



import {AccordionModule} from 'primeng/accordian';
import {MenuItem} from 'primeng/api';

this would be part of your import array in your module.
Then, you import the primeng dropdown by adding the following command to your import array.



import {DropdownModule} from 'primeng/dropdown';

NB: If you have been using various components ranging from material U.I to primeng and several others you notice that any component you use requires you to import the module containing the component,
for efficiency and to minimize the size of the application during the build and increase the efficiency of the application.You can try to import all the components you would use in your application in one module and the export them so you can import them wherever you want to use them in your application.
The lesser the time to build the faster the application.
You create an empty array and you initialise it, after that you subscribe to a service you have created which will contain a function getting all the data from the backend.
Then you go to your template which will contain a customized code of the primeng snippet of code which is:



<p-dropdown [options]="cities" [(ngModel)]="selectedCity" optionLabel="name"></p-dropdown>

where options will contain the name that encompasses all the data you are getting from the backend. In this instance, I will be using mock data to explain exactly how it works in the backend it the same principles.
The code snippet contains mock data gotten from primeng documentation.



interface City {
    name: string,
    code: string
}

export class DropdownDemo {

    cities: City[];

    selectedCity: City;

    constructor() {
        this.cities = [
            {name: 'New York', code: 'NY'},
            {name: 'Rome', code: 'RM'},
            {name: 'London', code: 'LDN'},
            {name: 'Istanbul', code: 'IST'},
            {name: 'Paris', code: 'PRS'}
        ];
    }

}

this is a mock data but with an array name of cities which is the name initialised on the top code snippet, now for you to filter through and pick from one of the array options which could be either the name or the code from the options provided. You use the "optionLabel" which can be equal to any of the two elements assigned values which are "name" and "code". if you use the element "name" the drop-down will contain these values: 'New York', 'Rome', 'London', 'Istanbul', and 'Paris'. In that exact order. If you choose to say the optionLabel equals "code" instead you would see the following values: 'NY', 'RM', 'LDN', 'IST', and 'PRS'. In that exact order.

IN CONCLUSIONS

You can easily replicate these processes when working with a live backend it works the same way.
That's it, for now, happy coding.

STARTING OUT WITH ANGULAR

Alphaexcel — Sun, 25 Sep 2022 23:57:32 +0000

Let's will start with
What is Angular
Angular is a javascript framework based on which is based on typescript which is a subset of Javascript and HTML.
It's also described as a component-based framework that uses typescript and HTML to build client-side single-page application "SPA".
Why Angular?

Angular is owned by Google which means frequent updates because a lot of software engineers are consistently researching and improving on it.
It's best to build enterprise applications.
It allows you to build a particular aspect of the application
being built without having to build the entire application.
It supports MVC and SPA which means Mobile Version Control and Single Page Application.
It allows testing and building at same in the same environment.
STRUCTURE OF ANGULAR **
The angular structure contains modules and components. These components each contain a typescript that can be recognized by "ts " and an HTML file.
The typescript file contains the logic and functional operations while the template or HTML file contains what is rendered on the browser.
Angular contains a root module where all component interactions start from.
Angular is structured in such a manner that different components interact with each other.
With the new angular 14 updates where standalone components have been added as one of the new features here, the standalone component acts like its own module.
In angular components can be structured so that each component performs a specific function.
One of the main benefits of the structure in angular is that it allows reusability of various functions in different components in different modules.

What Are The Main Concepts Of Angular

1.Component: This s the basic structural unit of how an angular application is based. Components hold specific functions, you may decide to create a component to handle just your Navbar in which you write a function specifically, just for the Navbar and you create another component to handle a specific page which will display on your application.

You can generate this component by simply typing this command in your Vs code terminal.

ng generate component componentName

This part that shows componentName represents the component's name and you may decide to give any name of your choice.
2. Component Interaction: This concept can be explained from the name it is simply how components communicate. If you want to communicate from a parent component to a child component where you pass data from parent to child you use the @Input decorator, while if you choose to pass data from child to parent you use the @Output decorator where you use an EventEmitter to capture the event.
NB: Decorators are design patterns or functions that describe how angular features work. They make modifications to a class or service.

3. Pipes: These are simple functions that you can use in the template expression to accept an input value and return a transformed value.
Pipes are useful because you can use them throughout your application, while you only declare each pipe once.
you can use a pipe to transform currency, date, string amount, etc.
you can see an example below where a date is changed from a raw string to January 26th, 1997



{{ 26/01/1997 | date: 'dd/MM/yyyy'}}

this symbol " |" represents a pipe anywhere it's used in angular.
4.Directives:These are classes that add additional behavior to your elements in your angular application.
You can use angular built-in directives to manage forms, lists, styles, and what your user sees.
The types of directives include:

Component directives: You can use these directives can be used in the template.
Attributes directives: You can use these to change the appearance or behavior of an element, component, or another directive.
Structural directives: You can use these to change the DOM layout by adding and removing elements.

TYPES OF BUILT-IN ATTRIBUTE DIRECTIVES

NgClass
NgStyle
NgModel

TYPES OF BUILT-IN STRUCTURAL DIRECTIVES
All the structural directives are written with an * in front of them

NgIf which you as an if statement in angular.
NgFor which you use to loop conditions in angular.
NgSwitch which allows you to display one or more DOM elements depending on the condition you set.
5. ROUTING: This simply can be described as how you navigate from one part of the page to the other. You can move from the home page to log in and back and forth that's the function of routing.
You start with adding the router-outlet which is a router functionality that you use to insert the exact component that matches the route you are trying to implement.
Two components of routing you need to know are:
The path that's where you are navigating to which you can always add with a



path: '',

The Component which you can use to specify the component to be rendered or displayed.



component: ComponentName,

6. Services: Let's use a real-life scenario to explain this if you want to use a data plan you need a data subscription, that data subscription is a service that allows you to access the internet.
So services in angular are no different they allow you to access API endpoints and ensure that the component doesn't become encumbered with too many functionalities. To use your service first you have to create a service using the following command



ng generate service ComponentName/ComponentName

Now you use dependency injection to inject your service into the constructor. Let's say you name your component photos and you created a service for photos, to use that service you would have to do the following.



ng generate service photos/photos

that's to create the component, then for you to use dependency injection in the constructor, you inject the service you have created by doing this



constructor(private photoservice: Photoservice) {}

above is called Dependency Injection.
7. Modules: Using a real-life context modules are like containers that contain components, pipes, services, and every other part of part related to the angular application. every component created would be part of the NgModule array that encompasses the imports and various declarations.
a module can be created with the following command.



ng generate module moduleName

NB: you can only have one root module that all other modules would be linked to.
That's it for now happy coding