Feb 7, 2025 14 min read

Could AI replace a developer?

After yet another busy day of sending out resume's I needed a distraction. Now when you see what I'm going to post as the result of my "need for a distraction" you may have serious concerns as to my mental state, but hey, what the hell.

So I had been wondering for a while, can they just cut out the middle man, the application developer, and just write a prompt and get a working application, so here I present my "experiment".

Prompt: Write a python program that will search the internet for code snippets related to the supplied quoted string:

Sure! Below is a Python program that searches the internet for code snippets related to a supplied quoted string. This program uses the GitHub Code Search API to find code files that match your query.

import requests
from urllib.parse import quote

def search_code_snippets(query):
    """
    Searches GitHub for code snippets related to the supplied query.

    Args:
        query (str): The search query string.

    Returns:
        list: A list of dictionaries containing repository name, file path, and URL.
    """
    # Encode the query string for URL
    encoded_query = quote(query)

    # GitHub Code Search API endpoint
    url = f"https://api.github.com/search/code?q={encoded_query}+in:file"

    # Make a GET request to the API
    response = requests.get(url)

    # Check for HTTP errors
    if response.status_code != 200:
        print(f"Error: {response.status_code} - {response.reason}")
        return []

    # Parse the JSON response
    results = response.json()

    # Extract relevant information from each item
    snippets = []
    for item in results.get('items', []):
        snippet = {
            'repository': item['repository']['full_name'],
            'file_path': item['path'],
            'html_url': item['html_url']
        }
        snippets.append(snippet)

    return snippets

def main():
    print("=== Code Snippet Search ===")
    query = input("Enter your search query (e.g., 'binary search in python'): ")

    print("\nSearching for code snippets related to your query...\n")
    snippets = search_code_snippets(query)

    if not snippets:
        print("No code snippets found for your query.")
        return

    # Display the search results
    for idx, snippet in enumerate(snippets, start=1):
        print(f"Result #{idx}")
        print(f"Repository: {snippet['repository']}")
        print(f"File Path: {snippet['file_path']}")
        print(f"URL: {snippet['html_url']}\n")

if __name__ == "__main__":
    main()

How the Program Works:

Imports Required Libraries:
- requests: For making HTTP requests to the GitHub API.
- urllib.parse.quote: For URL-encoding the query string.
Defines search_code_snippets Function:
- Takes a query string as input.
- Encodes the query for use in a URL.
- Sends a GET request to the GitHub Code Search API.
- Handles HTTP errors.
- Parses the JSON response and extracts the repository name, file path, and URL for each code snippet.
Main Execution Flow:
- Prompts the user to enter a search query.
- Calls the search_code_snippets function with the user's query.
- Prints out the search results in a readable format.

Usage Instructions:

View Results:
The program will display a list of code files from GitHub repositories that match your query, providing the repository name, file path, and a direct URL to view the code.

Enter Your Query:
When prompted, enter the code or concept you're interested in. For example:

Enter your search query (e.g., 'binary search in python'): "quick sort algorithm"

Run the Program:
Save the script to a file, say code_snippet_search.py, and run it using:

python code_snippet_search.py

Install Required Library:
Ensure you have the requests library installed. You can install it using:

pip install requests

Example Output:

=== Code Snippet Search ===
Enter your search query (e.g., 'binary search in python'): "merge sort in python"

Searching for code snippets related to your query...

Result #1
Repository: username/repo1
File Path: algorithms/merge_sort.py
URL: https://github.com/username/repo1/blob/main/algorithms/merge_sort.py

Result #2
Repository: username/repo2
File Path: sorting/merge_sort.py
URL: https://github.com/username/repo2/blob/main/sorting/merge_sort.py

...

Notes:

Search Query Tips:
- Use specific keywords to get more relevant results.
- Enclose multi-word queries in quotes to search for the exact phrase.
- You can refine your search using GitHub's search qualifiers.

GitHub API Rate Limiting: Unauthenticated requests to the GitHub API are limited to 10 requests per minute. If you exceed this limit, you may receive a 403 Forbidden error. To increase the rate limit, you can authenticate your requests by creating a GitHub Personal Access Token and including it in the headers:

headers = {'Authorization': 'token YOUR_PERSONAL_ACCESS_TOKEN'}
response = requests.get(url, headers=headers)

Disclaimer:

This program searches for publicly available code snippets on GitHub. Ensure that you comply with the respective licenses of any code you view or use. Always respect the intellectual property rights of others.

Prompt: now generate a web page wrapper that will run on an apache web server that will provide an input box that allow for entering a sting that will gen call the above supplied python program and display the output in an output box below the input

Sure! I'll help you create a web page wrapper that runs on an Apache web server. This web page will:

Provide an input box where users can enter a search string.
Call the Python program we created earlier to search for code snippets.
Display the output in an output box (or section) below the input.

Here's how you can achieve this:

Modify the Python Script to Work as a CGI Script.
Create an HTML Web Page with an Input Form.
Configure the Apache Web Server to Run CGI Scripts.
Test the Application.

Let's go through each step in detail.

1. Modify the Python Script to Work as a CGI Script

We need to adjust our Python script to function as a CGI script that can handle web requests.

Save the following script as search_snippets.py in your cgi-bin directory (e.g., /usr/lib/cgi-bin/ or /var/www/cgi-bin/):

#!/usr/bin/env python3

import cgi
import cgitb
import requests
from urllib.parse import quote
import html

# Enable error reporting
cgitb.enable()

def search_code_snippets(query):
    """
    Searches GitHub for code snippets related to the supplied query.

    Args:
        query (str): The search query string.

    Returns:
        list or str: A list of dictionaries containing repository name, file path, and URL, or an error message.
    """
    # Encode the query string for URL
    encoded_query = quote(query)

    # GitHub Code Search API endpoint
    url = f"https://api.github.com/search/code?q={encoded_query}+in:file"

    # Make a GET request to the API
    response = requests.get(url)

    # Check for HTTP errors
    if response.status_code != 200:
        return f"Error: {response.status_code} - {response.reason}"

    # Parse the JSON response
    results = response.json()

    # Extract relevant information from each item
    snippets = []
    for item in results.get('items', []):
        snippet = {
            'repository': item['repository']['full_name'],
            'file_path': item['path'],
            'html_url': item['html_url']
        }
        snippets.append(snippet)

    return snippets

def main():
    print("Content-Type: text/html")
    print()

    form = cgi.FieldStorage()
    query = form.getvalue('query', '')

    print("""
    <html>
    <head>
        <title>Code Snippet Search</title>
        <style>
            body { font-family: Arial, sans-serif; margin: 20px; }
            .result { margin-bottom: 15px; }
            .error { color: red; }
            input[type="text"] { width: 80%; padding: 8px; }
            input[type="submit"] { padding: 8px 16px; }
        </style>
    </head>
    <body>
        <h1>Code Snippet Search</h1>
        <form method="post" action="/cgi-bin/search_snippets.py">
            <input type="text" name="query" value="{0}" placeholder="Enter your search query">
            <input type="submit" value="Search">
        </form>
    """.format(html.escape(query)))

    if query:
        print("<h2>Search Results for '<em>{0}</em>':</h2>".format(html.escape(query)))

        # Call the search function
        results = search_code_snippets(query)

        if isinstance(results, str):
            # An error occurred
            print('<p class="error">{0}</p>'.format(html.escape(results)))
        elif results:
            # Display the search results
            for idx, snippet in enumerate(results, start=1):
                print(f"""
                <div class="result">
                    <strong>Result #{idx}</strong><br>
                    <strong>Repository:</strong> {html.escape(snippet['repository'])}<br>
                    <strong>File Path:</strong> {html.escape(snippet['file_path'])}<br>
                    <strong>URL:</strong> <a href="{html.escape(snippet['html_url'])}" target="_blank">{html.escape(snippet['html_url'])}</a>
                </div>
                """)
        else:
            print("<p>No code snippets found for your query.</p>")
    
    print("""
    </body>
    </html>
    """)

if __name__ == "__main__":
    main()

Explanation:

Shebang Line: #!/usr/bin/env python3 ensures the script runs with Python 3.
CGI Modules: Imported cgi and cgitb for handling form data and debugging.
HTML Escaping: Used html.escape() to sanitize user inputs and outputs.
Content-Type Header: Printed Content-Type: text/html to denote the response is HTML.
HTML Output: The script outputs an HTML page with the form and results.

2. Create an HTML Web Page with an Input Form

Although the CGI script generates the form, you might want a separate HTML page that users can access directly.

Save the following as index.html in your web server's root directory (e.g., /var/www/html/):

<!DOCTYPE html>
<html>
<head>
    <title>Code Snippet Search</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        input[type="text"] { width: 80%; padding: 8px; }
        input[type="submit"] { padding: 8px 16px; }
    </style>
</head>
<body>
    <h1>Code Snippet Search</h1>
    <form method="post" action="/cgi-bin/search_snippets.py">
        <input type="text" name="query" placeholder="Enter your search query">
        <input type="submit" value="Search">
    </form>
</body>
</html>

Explanation:

This HTML page provides an input form for users.
The form submits to the CGI script search_snippets.py.

3. Configure the Apache Web Server to Run CGI Scripts

Apache needs to be configured to execute CGI scripts.

Steps:

Restart ApacheApply the changes by restarting Apache:

sudo systemctl restart apache2

Install Required Python ModulesInstall the requests library:

sudo apt-get update
sudo apt-get install python3-pip
sudo pip3 install requests

Set PermissionsEnsure that the CGI script is executable:

sudo chmod 755 /usr/lib/cgi-bin/search_snippets.py

Configure the CGI DirectoryEnsure the cgi-bin directory is correctly set up in your Apache configuration.Edit the default site configuration:

sudo nano /etc/apache2/sites-available/000-default.conf

Add the following configuration if it's not already present:

ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
<Directory "/usr/lib/cgi-bin">
    AllowOverride None
    Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
    Require all granted
</Directory>

Adjust the paths if your cgi-bin directory is located elsewhere.

Enable CGI ModuleRun the following command to enable the CGI module:

sudo a2enmod cgi

4. Test the Application

Open your web browser and navigate to http://your_server_ip/.
You should see the input form from index.html.
Enter a search query, e.g., "binary search in python", and click Search.
The browser should display the results generated by the search_snippets.py CGI script.

Example Output

Search Page:

![Search Page](data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDgwIiBoZWlnaHQ9IjM2MCIgZmlsbD0iI0U1RTVFNSI+PHJlY3Qgd2lkdGg9IjQ4MCIgaGVpZ2h0PSIzNjAiIGZpbGw9IiNFNUU1RTUiIHJ4PSIxNSIvPjx0ZXh0IHg9IjEwIiB5PSIyMCIgZm9udC1zaXplPSIyMHB4IiBmaWxsPSIjNzI3MjcyIj5TZWFyY2ggUGFnZTwvdGV4dD48dGV4dCB4PSIxMCIgeT0iNTAiIGZvbnQtc2l6ZT0iMTZweCIgZmlsbD0iIzcyNzI3MiI+W0lucHV0IEZvcm1dPC90ZXh0Pjwvc3ZnPg==)

(This is a placeholder image.)

Results Page:

After submitting the search, the results should appear below the form.

Notes

GitHub API Rate Limiting
- Unauthenticated requests have a low rate limit.
- To increase the limit, use a GitHub Personal Access Token.
Security Considerations
- Input Sanitization: Used html.escape() to prevent HTML injection.
- Do Not Expose Tokens: If using a token, ensure it's stored securely and not exposed in the source code.
Error Handling
- Enabled detailed error reporting with cgitb.enable().
- Errors will be displayed in the browser, which is helpful for debugging but may not be suitable for a production environment.

Modify the search_code_snippets function:

import os

GITHUB_TOKEN = 'YOUR_PERSONAL_ACCESS_TOKEN'  # Store this securely

def search_code_snippets(query):
    # ...
    headers = {'Authorization': f'token {GITHUB_TOKEN}'}
    response = requests.get(url, headers=headers)
    # ...

Troubleshooting

500 Internal Server Error
- Common causes include:
  - Incorrect file permissions.
  - Missing modules (e.g., requests not installed).
  - Syntax errors in the script.
Script Downloads Instead of Executing
- Ensure Options +ExecCGI is set in your Apache configuration for the cgi-bin directory.
- Ensure the script has the correct file extension (.py).

Check the Apache error logs:

sudo tail /var/log/apache2/error.log

Disclaimer

This application searches for publicly available code snippets on GitHub. Ensure you comply with the respective licenses when using any code retrieved by this application. Always respect the intellectual property rights of others.

Let me know if you have any questions or need further assistance!

Prompt: rewrite the search_snippets.py code to include the GitHub API Rate Limiting code snippet

Certainly! Below is the updated search_snippets.py code that includes handling for GitHub API rate limiting by using a Personal Access Token (PAT). This token increases your API rate limit, allowing you to make more requests without hitting the unauthenticated rate limits.

Important Security Note: You should never hard-code your Personal Access Token directly into your scripts, especially if the script is accessible to others or stored in a public repository. Instead, you should securely store the token, such as in an environment variable.

Updated `search_snippets.py` Script

Save the following script as search_snippets.py in your cgi-bin directory:

#!/usr/bin/env python3

import cgi
import cgitb
import requests
from urllib.parse import quote
import html
import os

# Enable error reporting
cgitb.enable()

# Retrieve the GitHub Personal Access Token from an environment variable
GITHUB_TOKEN = os.environ.get('GITHUB_TOKEN')

def search_code_snippets(query):
    """
    Searches GitHub for code snippets related to the supplied query.

    Args:
        query (str): The search query string.

    Returns:
        list or str: A list of dictionaries containing repository name, file path, and URL,
                     or an error message.
    """
    # Encode the query string for URL
    encoded_query = quote(query)

    # GitHub Code Search API endpoint
    url = f"https://api.github.com/search/code?q={encoded_query}+in:file"

    headers = {}
    if GITHUB_TOKEN:
        headers['Authorization'] = f'token {GITHUB_TOKEN}'

    # Make a GET request to the API
    response = requests.get(url, headers=headers)

    # Check for HTTP errors
    if response.status_code != 200:
        # Extract error message from response
        error_message = response.json().get('message', 'Unknown error occurred.')
        return f"Error: {response.status_code} - {error_message}"

    # Parse the JSON response
    results = response.json()

    # Extract relevant information from each item
    snippets = []
    for item in results.get('items', []):
        snippet = {
            'repository': item['repository']['full_name'],
            'file_path': item['path'],
            'html_url': item['html_url']
        }
        snippets.append(snippet)

    return snippets

def main():
    print("Content-Type: text/html")
    print()

    form = cgi.FieldStorage()
    query = form.getvalue('query', '')

    print("""
    <html>
    <head>
        <title>Code Snippet Search</title>
        <style>
            body { font-family: Arial, sans-serif; margin: 20px; }
            .result { margin-bottom: 15px; }
            .error { color: red; }
            input[type="text"] { width: 80%; padding: 8px; }
            input[type="submit"] { padding: 8px 16px; }
        </style>
    </head>
    <body>
        <h1>Code Snippet Search</h1>
        <form method="post" action="/cgi-bin/search_snippets.py">
            <input type="text" name="query" value="{0}" placeholder="Enter your search query">
            <input type="submit" value="Search">
        </form>
    """.format(html.escape(query)))

    if query:
        print("<h2>Search Results for '<em>{0}</em>':</h2>".format(html.escape(query)))

        # Call the search function
        results = search_code_snippets(query)

        if isinstance(results, str):
            # An error occurred
            print('<p class="error">{0}</p>'.format(html.escape(results)))
        elif results:
            # Display the search results
            for idx, snippet in enumerate(results, start=1):
                print(f"""
                <div class="result">
                    <strong>Result #{idx}</strong><br>
                    <strong>Repository:</strong> {html.escape(snippet['repository'])}<br>
                    <strong>File Path:</strong> {html.escape(snippet['file_path'])}<br>
                    <strong>URL:</strong> <a href="{html.escape(snippet['html_url'])}" target="_blank">{html.escape(snippet['html_url'])}</a>
                </div>
                """)
        else:
            print("<p>No code snippets found for your query.</p>")

    print("""
    </body>
    </html>
    """)

if __name__ == "__main__":
        main()

Steps to Set Up the Script with GitHub API Rate Limiting Handling

1. Create a GitHub Personal Access Token (PAT)

Log in to your GitHub account.
Navigate to Settings.
On the left sidebar, click on Developer settings.
Click on Personal access tokens.
Click on Tokens (classic) (or Fine-grained tokens if you prefer).
Click Generate new token.
Set a Note (e.g., "Code Snippet Search App").
Set an expiration date or select No expiration for non-expiring tokens.
Under Select scopes, choose public_repo to allow access to public repositories.
Click Generate token.
Copy the token now. You won't be able to see it again.

2. Store the Token Securely

To prevent exposing your token, store it in an environment variable.

Option A: Set the Environment Variable in Apache Configuration

Save and close the file (Ctrl+O, Enter, Ctrl+X).

Restart Apache:

sudo systemctl restart apache2

Add the following line at the end (replace YOUR_PERSONAL_ACCESS_TOKEN with your actual token):

export GITHUB_TOKEN=YOUR_PERSONAL_ACCESS_TOKEN

Open the Apache configuration file:

sudo nano /etc/apache2/envvars

Option B: Set the Environment Variable in the CGI Script

Alternatively, you can set the environment variable in the script itself. However, be cautious—embedding the token directly into the script can be a security risk if the script is accessible to others.

If you choose this method, add the following line at the top of your script (not recommended for production use):

os.environ['GITHUB_TOKEN'] = 'YOUR_PERSONAL_ACCESS_TOKEN'

3. Ensure Necessary Permissions and Modules

Ensure the script has execute permissions:

sudo chmod 755 /usr/lib/cgi-bin/search_snippets.py

Make sure the requests library is installed and accessible to your script:

sudo pip3 install requests

4. Testing the Application

Navigate to your web page (e.g., http://your_server_ip/).
Enter a search query and submit.
The application should display results, and you should no longer encounter rate limit issues unless you exceed the higher authenticated rate limit.

Explanation of Changes

Improved Error HandlingWe extract error messages from the GitHub API response for better error reporting.

if response.status_code != 200:
    # Extract error message from response
    error_message = response.json().get('message', 'Unknown error occurred.')
    return f"Error: {response.status_code} - {error_message}"

Include Authorization Header if Token is AvailableWe modify the search_code_snippets function to include the Authorization header when making the API request.

headers = {}
if GITHUB_TOKEN:
    headers['Authorization'] = f'token {GITHUB_TOKEN}'

response = requests.get(url, headers=headers)

Retrieve GITHUB_TOKEN from Environment VariableWe attempt to get the GITHUB_TOKEN environment variable. If it's not set, GITHUB_TOKEN will be None.

GITHUB_TOKEN = os.environ.get('GITHUB_TOKEN')

Import os ModuleWe import the os module to access environment variables.

import os

Important Security Considerations

Do Not Hard-code TokensNever hard-code your personal access token directly into the script if others can access the script. This can lead to unauthorized access to your GitHub account if the token is compromised.
Secure StorageStore sensitive information like tokens securely, utilizing environment variables or secure credential storage mechanisms.
PermissionsEnsure that the script and any files containing sensitive information have appropriate permissions set to prevent unauthorized access.
Public RepositoriesBe cautious about pushing scripts containing tokens to public repositories. Always verify that no sensitive information is exposed.

Additional Notes

GitHub API Rate Limits with AuthenticationBy authenticating your requests with a personal access token, you increase the rate limit to up to 5,000 requests per hour for authenticated requests.
Error MessagesThe script now provides more informative error messages by extracting the message from the API response, helping diagnose issues like invalid tokens or exceeded rate limits.
Fine-Grained Personal Access TokensGitHub now recommends using fine-grained personal access tokens. When generating a token, select only the permissions necessary for your application.
Monitoring UsageKeep an eye on your API usage to ensure you don't exceed rate limits and to monitor for any unusual activity.

Troubleshooting

Invalid or Missing TokenIf you encounter authentication errors, ensure that:
- The token is correctly set in the environment variable.
- The token has the necessary permissions.
- The token has not expired or been revoked.
Permissions IssuesIf the script isn't executing properly:
- Verify the execute permissions (chmod 755).
Module Import ErrorsIf the script cannot find the requests module:
- Ensure requests is installed for the version of Python being used by Apache.

Verify the path by running:

which python3

Sometimes, the Apache server might use a different Python environment. You might need to install requests system-wide or adjust the shebang line to point to the correct Python interpreter.

#!/usr/bin/env python3

Check Apache's error logs for clues:

sudo tail /var/log/apache2/error.log

Conclusion

By incorporating your GitHub Personal Access Token into the script via environment variables, you increase your API rate limit and reduce the likelihood of encountering rate limit errors during use. Always ensure that you handle sensitive information securely to maintain the integrity and security of your account and systems.

Let me know if you need further assistance or have any questions!

So this is a far as I took the "experiment" for now anyway, I would always go pack to the AI reload this session and proceed to "develop" the application. My conclusion is that yes AI can write an application, but unless it's a "developer" writing the prompts and reviewing the AI output it's really not going to replace anyone.

AI is a tool, just like a calculator, and as such used by the right people can and will make individuals much more productive. It's not, yet at least yet, a super virtual entity that's going to render everyone "surplus to requirements". So embrace the technology and "learn" to use it, and use it well

I'm afraid to tell you that you are going to still have to use the grey matter that sits on top of your head, otherwise known as your brain. And as such AI can equally be used for good or bad, just like everything else that the human race dreams up, and there will always be people who will try to use the tools to make a "quick buck". There will however just as many people out there, hopefully, that will use the tool to do some amazing things, and do them much quicker.

So that my experiment, probably one of many yet to come, let me know your thoughts and feeling on the all this, if you care...

How the Program Works:

Usage Instructions:

Example Output:

Notes:

Disclaimer:

1. Modify the Python Script to Work as a CGI Script

Explanation:

2. Create an HTML Web Page with an Input Form

3. Configure the Apache Web Server to Run CGI Scripts

Steps:

4. Test the Application

Example Output

Notes

Troubleshooting

Disclaimer

Updated search_snippets.py Script

Steps to Set Up the Script with GitHub API Rate Limiting Handling

1. Create a GitHub Personal Access Token (PAT)

2. Store the Token Securely

3. Ensure Necessary Permissions and Modules

4. Testing the Application

Explanation of Changes

Important Security Considerations

Additional Notes

Troubleshooting

Conclusion

Updated `search_snippets.py` Script