DEV Community: BMega

Is AI Ready to Replace Software Developers?

BMega — Sat, 01 Feb 2025 13:51:21 +0000

We are currently in the AI bubble. AI is the new buzzword being thrown into every conversation lately.

We now have Deepseek, which seems to be better than ChatGPT. Multiple AI startups and evangelists have emerged, all claiming that AI is the future and will replace many existing jobs, including software developers. Being a software engineer myself, I was curious to know if AI is really ready to replace me.

First, I've been an avid user of ChatGPT, and I can attest that it has indeed improved my productivity — from brainstorming ideas to solving bugs. But it's not perfect. It still requires a lot of correction and refinement. This is where another popular buzzword comes in Prompt Engineering. Prompt engineering is the process of refining prompts to get the desired output. This is a tedious process and still requires human intervention.

I stumbled upon a startup called Lovable.dev, which claims to be a superhuman full-stack engineer. The process of using it is quite simple—just prompt it to create anything, and it will generate a Git repository with the code, which you can then add to your own GitHub account. It also has the ability to create a database on Supabase and connect it to your app. I decided to test it out by creating a simple chatbot app that:

Allows users to log in via email providers and regular email/password authentication
Uses the ChatGPT Assistant API for message responses
Saves the message history for each user

Sounds simple, right?

I was impressed by how fast it created the app, but this didn't come without bugs and errors—though, surprisingly, it did attempt to self-correct. It took multiple prompts to get everything right, but still, the results were impressive. Even though the app was very lean and bare-bones, it was a good starting point for a POC or MVP.

Verdict

Who is this for?

This is for non-technical founders or PMs who want to quickly prototype an idea before committing an entire dev team or sprint to it.

Given the simple app I built, if I wanted to add more complex features, it would be faster to do it myself rather than continuously prompting the AI. Secondly, context is a huge factor in software development. AI does not have context regarding business requirements or users’ needs that are not explicitly documented—especially those that are implicit or inferred. It can only do what it's told, and this is where the human touch comes in. For example, designing the data layer isn’t always straightforward.

Thirdly, most developers work on existing codebases, which requires a deep understanding of the architecture before making changes. Even though some AI agents can explain code, you still need context to understand how everything fits together to meet user needs.

Conclusion

AI is not ready to replace software developers, but it can significantly speed up the development process.

Valid Anagram

BMega — Fri, 27 Dec 2024 22:20:18 +0000

This article will highlight two approaches to this problem

Question

Leetcode link -> https://leetcode.com/problems/valid-anagram/description/

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase,
typically using all the original letters exactly once.

Example 1:

Input: s = "anagram", t = "nagaram"
Output: true


Example 2:

Input: s = "rat", t = "car"
Output: false


Constraints:

1 <= s.length, t.length <= 5 * 104
s and t consist of lowercase English letters.

Two approaches

For both approaches if the length of both strings is not equal return False

1. Using Counters

Create two counters for each string
loop through each string counting the number of occurrences for each character
Compare the two counters and return the boolean output

Complexity

Time

𝑂(𝑛)

loop the two string (s and t) = 𝑂(𝑛) + 𝑂(𝑛)
insertion into dict counters = 𝑂(1) + 𝑂(1)
compare dicts = 𝑂(1)

2𝑂(𝑛) + 3𝑂(1) = 𝑂(𝑛)

Space

𝑂(1)

2 counters = 𝑂(1) + 𝑂(1)

2𝑂(1)

Code

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s) != len(t):
            return False

        s_counter = {}
        t_counter = {}

        for char in s:
            if char in s_counter:
                s_counter[char] += 1
            else:
                s_counter[char] = 1

        for char in t:
            if char in t_counter:
                t_counter[char] += 1
            else:
                t_counter[char] = 1

        return s_counter == t_counter

2. Using inbuilt sort method

Use python's inbuilt sorted() method for each string
Compare if the two sorted strings are equal

Complexity

Time

𝑂(𝑛 log 𝑛 )

The python's sorted() function uses a Timsort algorithm = 𝑂(𝑛 log 𝑛 ) + 𝑂(𝑛 log 𝑛 )
compare the two strings = 𝑂(𝑛)

2𝑂(𝑛 log 𝑛 ) + 𝑂(𝑛) = 𝑂(𝑛 log 𝑛 )

Space

𝑂(𝑛)

Sort function will create a new sorted string from the input string = 𝑂(𝑛) + 𝑂(𝑛)
compare the two strings = 𝑂(𝑛)

3𝑂(𝑛) = 𝑂(𝑛)

Code

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s) != len(t):
            return False
        return sorted(s) == sorted(t)

Two sum

BMega — Sun, 10 Nov 2024 18:16:00 +0000

This article will highlight two approaches the brute force and the efficient approach

Question

Leetcode link -> https://leetcode.com/problems/two-sum/description/

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1

Input: nums = [2,7,11,15], target = 9
Output: [0,1]

Explanation: Because nums[0] + nums[1] == 9, 
we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]


Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]


Constraints:

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
Only one valid answer exists.

Follow-up: Can you come up with an algorithm that is less than 𝑂( 𝑛 ² ) time complexity?

Brute Force

Use double for loop, for each value add the values and check if they equal the target

Complexity

Time

𝑂( 𝑛 ² )

Since its a double for loop, each element is paired with every other element exactly once

Space

𝑂( 1 )

This approach does not use any extra data structures that grow with the size of the input.

which means it is constant space.

Code

class Solution:
    for i in range(len(nums)):
      for j in range(i+1, len(nums)):
         if(nums[i] + nums[j] == target):
            return [i,j]
    return None

Efficient approach

Use a hashmap

Use one for loop and enumerate list
target minus each element
if compliment in hashmap return the index of the compliment in the hashmap and the current index in loop
else add element as key and index as value

Complexity

Time

𝑂(𝑛)

Because we traverse the list once, and dictionary operations (insertion and lookup) are O( 1 ) on average

Space

𝑂(𝑛)

In the worst case, if there are no two numbers that sum up to the target, every element will be stored in the hash map.
Therefore, the space complexity is 𝑂(𝑛) where 𝑛 is the number of elements in the list.

Code

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        two_hash = {}
        for i, num in enumerate(nums):
            compliment = target - num
            if compliment in two_hash:
                return [two_hash[compliment], i]
            two_hash[num] = i
        return None