Verwenden von Copilot zum Migrieren eines Projekts zu einer anderen Programmiersprache

GitHub Copilot Chat kann dir dabei helfen, ein Projekt zu einer anderen Programmiersprache zu migrieren. In diesem Leitfaden wird beschrieben, welche Schritte für einen Migrationsprozess erforderlich sind. Zudem ist ein Beispiel für die Migration von PHP zu Python enthalten.

In diesem Artikel

Einführung

Das Migrieren eines Projekts zu einer neuen Programmiersprache kann eine schwierige und zeitaufwendige Aufgabe sein. GitHub Copilot kann dir bei diesem Prozess helfen, indem die erforderlichen Änderungen erläutert werden und Ersatzcode in der neuen Sprache vorgeschlagen wird.

Prinzipien der Migration eines Projekts zu einer neuen Sprache

Berücksichtige die folgenden Punkte, bevor du einen Migrationsprozess startest:

  • Programmierkenntnisse

    Stelle sicher, dass du mit beiden Programmiersprachen bestens vertraut bist. Obwohl Copilot Code für dich übersetzen kann, musst du die vorgeschlagenen Auswahlmöglichkeiten verstehen und entscheiden, ob du die Vorschläge verwenden oder weitere alternative Vorschläge erhalten möchtest.

  • Wissen im Zusammenhang mit dem aktuell verwendeten System

    Stelle sicher, dass du neben den für Benutzende zur Verfügung stehenden Funktionen und Features auch die Architektur und Logik des aktuellen Systems verstehst. Du musst überprüfen können, ob der übersetzte Code all die entsprechenden Vorgänge wie der ursprüngliche Code ausführt und dieselben Ergebnisse generiert.

  • Verwenden von KI als Hilfe

    Wenn du einen bestimmten Teil des Codes nicht verstehst, den du übersetzen möchtest, kannst du entweder für die gesamte Datei oder für einen ausgewählten Teil des Codes in einer Datei das Copilot-Feature für Erklärungen verwenden. Weitere Informationen findest du unter Stellen von GitHub Copilot-Fragen in Ihrer IDE.

  • Zeitplan für Abschluss der Migration

    Die Konvertierung ist ein mehrstufiger Prozess. Je größer das zu konvertierende Projekt ist, desto höher ist die Anzahl der Schritte, die du ausführen musst. Stelle sicher, dass du genügend Zeit hast, um den gesamten Prozess abzuschließen.

  • Iteratives Arbeiten

    Du solltest versuchen, einzelne Teile deines Projekts separat zu konvertieren. Stelle sicher, dass du alle vorgenommenen Änderungen überprüft hast, bevor du mit einem anderen Teil des Projekts beginnst. Schreibe während der Bearbeitung Tests für die einzelnen Teile des Projekts, damit du sicher sein kannst, dass alle neuen Komponenten wie erwartet funktionieren.

  • Vermeiden von Komplexität im Prozess

    Zunächst solltest du eine gleichwertige Konvertierung durchführen. Dies ist nicht für den gesamten Code in deinem Projekt möglich. Um zusätzliche Komplexität bei der Migrationsaufgabe zu vermeiden, solltest du jedoch versuchen, die Anzahl der neuen eingeführten Änderungen einzuschränken, die sich nicht auf das Übersetzen des Codes und die Verwendung eines neuen Frameworks und der entsprechenden Abhängigkeiten beziehen.

  • Benchmarking und Umgestalten des übersetzten Codes

    Nachdem du die erste Konvertierung abgeschlossen hast und über ein funktionierendes System verfügst, kannst du Benchmarkingvorgänge ausführen, um das alte und das neue System zu vergleichen. Du kannst den Code jetzt in der neuen Sprache umgestalten. Dies ist eine Möglichkeit, den Code zu optimieren und technische Schulden zu reduzieren.

Verwenden von Copilot zum Migrieren eines Projekts zu einer neuen Sprache

Wenn du dich mit dem vorhandenen Projekt bereits vertraut gemacht hast, empfiehlt es sich für den Start einer Migration, einen Branch des Repositorys in deinem Editor zu öffnen und Copilot um Hilfe zu bitten.

  1. Öffne das Copilot Chat-Panel in deinem Editor. Weitere Informationen findest du unter Stellen von GitHub Copilot-Fragen in Ihrer IDE.

  2. Bitte Copilot darum, die Schritte zu beschreiben, die du ausführen musst, um das Projekt zur neuen Sprache zu migrieren.

    Für die Migration von PHP zu Python könntest du beispielsweise Folgendes fragen:

    @workspace I want to migrate this project from PHP to Python. Give me a high level overview of the steps I need to take. Don't go into detail at this stage.

    Note

    Der Chatteilnehmer @workspace legt die Dateien im aktuellen Arbeitsbereich als Kontext für die Frage fest, die du stellst.

    In der Regel gibt Copilot eine Liste der Schritte zurück, die du zum Migrieren des Projekts ausführen musst.

  3. Kopiere die Antwort von Copilot, und speichere sie an einer beliebigen Stelle, um während des Prozesses darauf zurückgreifen zu können.

  4. Führe die einzelnen Schritte des Prozesses aus, und bitte Copilot bei Bedarf um Hilfe.

    Überprüfe jeden Vorschlag von Copilot sorgfältig. Stelle sicher, dass du den vorgeschlagenen Code verstehst, und bewerte, ob er für dein Projekt geeignet ist. Wenn du diesbezüglich unsicher bist, fordere Copilot auf, dir den Code zu erklären.

    Wenn du der Meinung bist, dass ein Vorschlag von Copilot in irgendeiner Weise nicht richtig ist, bitte das Tool um einen alternativen Vorschlag.

  5. Sobald du einen Punkt im Migrationsprozess für die Komponente erreicht hast, an dem sie ausgeführt werden kann, kannst du überprüfen, ob sie wie erwartet funktioniert. Wenn ein Fehler generiert wird, kopiere den Fehler in die Copilot Chat-Ansicht, und nutze Copilot, um den Fehler zu beheben.

  6. Nachdem du die ursprüngliche Konvertierung abgeschlossen hast, verwende Copilot, um Hilfe beim Umgestalten des Codes in der neuen Sprache zu erhalten. Weitere Informationen finden Sie unter Refactoring von Code mit GitHub Copilot.

Beispiel: Migrieren eines PHP-Projekts zu Python

Im folgenden Beispiel wird die Migration einer einfachen Webanwendung von PHP zu Python beschrieben. Selbst wenn es sich hierbei nicht um die Programmiersprachen handelt, die du für die Migration verwendest, ist es möglicherweise hilfreich, die hier beschriebenen Schritte zu befolgen, um dich mit der Projektmigration vertraut zu machen. Die Schritte sind für die Migration anderer kleiner Projekte von einer Sprache zu einer anderen ähnlich.

Screenshot: Website „Simple PHP Website“ vor der Migration von PHP zu Python

In diesem Beispiel wird von Folgendem ausgegangen:

  • Du arbeitest in Visual Studio Code.
  • Du hast beide Sprachen installiert: PHP und Python-Version 3.12 oder höher.

Migrieren eines einfachen Websiteprojekts

Du wirst den Code in diesem öffentlichen Repository auf GitHub migrieren: docs/simple-php-website.

Das Repository besteht aus den folgenden Dateien.

.gitignore
.htaccess
LICENSE
content
├── 404.phtml
├── about-us.phtml
├── contact.phtml
├── home.phtml
└── products.phtml
includes
├── config.php
└── functions.php
index.php
readme.md
template
├── style.css
└── template.php

In diesem Beispiel werden die Prompts vorgeschlagen, die du in Copilot Chat eingeben kannst, um die Migration abzuschließen. Zudem sind die Antworten enthalten, die Copilot für eine Instanz dieser Migration zurückgegeben hat. Da die Copilot Chat-Antworten nicht deterministisch sind, erhältst du möglicherweise Antworten, die sich von den hier gezeigten leicht unterscheiden.

Während eines Migrationsprozesses werden wahrscheinlich Fehler angezeigt, die du beheben musst, bevor du fortfährst. Dabei kann Ihnen Copilot helfen. Das Beispiel enthält einige Fehler und zeigt, wie du Copilot um Hilfe bitten kannst, diese zu beheben.

Da sich die Antworten von Copilot Chat wahrscheinlich von den hier gezeigten Antworten unterscheiden, werden möglicherweise unterschiedliche Fehler angezeigt. Daher ist es ggf. einfacher, diese Beispielmigration mit den hier angezeigten Antworten zu durchlaufen, anstatt sie selbst über Copilot abzurufen.

Nach Abschluss dieser Beispielmigration kannst du dann dieselbe Methodik für dein eigenes Projekt verwenden.

  1. Klone zunächst eine Kopie des Repositorys auf deinen lokalen Computer.

  2. Führe die Anwendung aus, um zu überprüfen, ob sie funktioniert.

    Navigiere hierfür in einem Terminal zum Stamm des geklonten Repositorys, und führe den folgenden Befehl aus:

    Shell
     php -S localhost:8000

    Wechsle dann in einem Browser zu http://localhost:8000.

  3. Navigiere auf der Website, um dich mit ihr vertraut zu machen, sodass du überprüfen kannst, ob die Migration erfolgreich war.

  4. Erstelle einen Arbeitsbranch in deinem Repository, und öffne ihn als neuen Arbeitsbereich in Visual Studio Code.

  5. Mache dich mit dem Inhalt und der Architektur des vorhandenen Projekts vertraut. Copilot kann dir dabei helfen:

    1. Öffne die Copilot Chat-Ansicht.

    2. Gib einen Prompt wie den folgenden ein:

      @workspace Describe this project in detail, explaining what the various components do and how they interact.

  6. Fordere Copilot auf, eine allgemeine Übersicht über den Migrationsprozess zurückzugeben:

    @workspace I want to migrate this project from PHP to Python. Give me a high level overview of the steps I need to take. Don't go into detail at this stage.

    Copilot antwortet mit Anweisungen wie den folgenden:

    To migrate this project from PHP to Python, follow these high-level steps:

1. Set Up Python Environment:
   - Install Python and set up a virtual environment.
   - Install necessary packages (e.g., Flask for web framework).

2. Convert Configuration:
   - Translate the configuration settings from config.php to a Python configuration file.

3. Rewrite Functions:
   - Convert PHP functions in functions.php to Python functions.

4. Create Flask Application:
   - Set up a Flask application to handle routing and views.
   - Map the routes to corresponding views.

5. Convert Templates:
   - Translate template.php to a Jinja2 template.
   - Update the CSS file path in the template.

6. Convert Content Pages:
   - Convert .phtml content files to HTML or Jinja2 templates.

7. Update .htaccess Rules:
   - Translate .htaccess rewrite rules to Flask route handling.

8. Run and Test:
   - Run the Flask application and test all routes and functionalities.
   - Ensure the site works as expected and fix any issues.

9. Documentation:
   - Update the readme.md with new instructions for running the Python project.

  7. Kopiere die Antwort von Copilot, und speichere sie an einer beliebigen Stelle, um während des verbleibenden Teils des Prozesses darauf zurückgreifen zu können. Du wirst jeden dieser Schritte durcharbeiten und Copilot darum bitten, dich im weiteren Verlauf zu unterstützen.

  8. Wenn du noch nicht entschieden hast, welches Python-Framework du verwenden möchtest, kannst du Copilot um Rat fragen:

    @workspace What Python frameworks can I use for this project once it is migrated to Python? Give me a selection of options, with a brief summary of the pros and cons of each in relation to this website project. Which framework would you recommend?

    Copilot gibt Informationen zu verschiedenen Frameworks zurück und kommt zu folgendem Ergebnis:

    For a project like yours - which is a simple, content-driven website - Flask is highly recommended. Its simplicity, flexibility, and ease of use (especially with its templating system that can easily replace your current PHP template structure) make it a great fit.

    Du nimmst den Ratschlag von Copilot an und verwendest Flask.

  9. Zurück in der allgemeinen Copilot-Ansicht besteht der erste Schritt darin, eine Python-Umgebung einzurichten und die erforderlichen Pakete zu installieren. Gib in Copilot Chat Folgendes ein, um herauszufinden, welche Schritte du ausführen musst:

    @workspace I want to use Flask. Tell me how to set up a virtual environment and install the necessary packages.

    Copilot antwortet mit Anweisungen wie den folgenden:

    1. Create a virtual environment:
   - Open a terminal and navigate to your project directory.
   - Run the following command to create a virtual environment:
     python3 -m venv venv

2. Activate the virtual environment:
   - On macOS and Linux:
     source venv/bin/activate

   - On Windows:
     venv\Scripts\activate

3. Install Flask and necessary packages:
   - With the virtual environment activated, run the following command
     to install Flask and other necessary packages:
     pip install Flask

4. Verify the installation:
   - You can verify that Flask is installed by running:
     pip list

  10. Befolge die Anweisungen von Copilot, und verwende pip list, um zu überprüfen, ob Flask installiert ist.

  11. Zurück in der Copilot-Ansicht für den Migrationsprozess besteht der nächste Schritt darin, die Konfiguration zu konvertieren. Bitte Copilot hierbei um Hilfe. Zum Beispiel:

    @workspace As the first step in migrating this project from PHP to Python, create a Python configuration file by converting the functions in functions.php to Python functions. Tell me where to locate the Python config file in the project.

    Copilot schlägt vor, eine Datei namens config.py im includes-Verzeichnis zu erstellen, die den folgenden Code enthält.

    Python
    config = {
   'name': 'Simple Python Website',
   'site_url': '',
   'pretty_uri': False,
   'nav_menu': {
      '': 'Home',
      'about-us': 'About Us',
      'products': 'Products',
      'contact': 'Contact',
   },
  'template_path': 'template',
  'content_path': 'content',
  'version': 'v3.1',
}

def get_config(key=''):
   return config.get(key, None)

def site_name():
   return get_config('name')

def site_url():
   return get_config('site_url')

def site_version():
   return get_config('version')

def nav_menu(sep=' | '):
   nav_menu = ''
   nav_items = get_config('nav_menu')

   for uri, name in nav_items.items():
      query_string = request.args.get('page', '')
      class_active = ' active' if query_string == uri else ''
      url = f"{get_config('site_url')}/{'' if get_config('pretty_uri') or uri == '' else '?page='}{uri}"

      nav_menu += f'<a href="{url}" title="{name}" class="item{class_active}">{name}</a>{sep}'

   return nav_menu.strip(sep)

def page_title():
   page = request.args.get('page', 'Home')
   return ' '.join(word.capitalize() for word in page.split('-'))

def page_content():
   page = request.args.get('page', 'home')
   path = os.path.join(os.getcwd(), get_config('content_path'), f'{page}.phtml')

   if not os.path.exists(path):
      path = os.path.join(os.getcwd(), get_config('content_path'), '404.phtml')

   with open(path, 'r') as file:
      return file.read()

def init():
   template_path = os.path.join(get_config('template_path'), 'template.html')
   with open(template_path, 'r') as file:
      return file.read()

  12. Erstelle die includes/config.py-Datei, und lösche die vorhandene includes/config.php-Datei.

  13. Wenn du zurück zur Übersicht navigierst, kannst du Copilot bitten, dich beim Umschreiben von PHP-Funktionen zu unterstützen.

    @workspace Continuing the migration of this project from PHP to Python, create Python functions to replace the existing PHP functions. Tell me where to locate the Python functions in the project.

    Copilot schlägt vor, eine Datei namens functions.py im includes-Verzeichnis zu erstellen, die den folgenden Code enthält.

    Python
    import os
from flask import request
from .config import get_config

def site_name():
   return get_config('name')

def site_url():
   return get_config('site_url')

def site_version():
   return get_config('version')

def nav_menu(sep=' | '):
   nav_menu = ''
   nav_items = get_config('nav_menu')

   for uri, name in nav_items.items():
      query_string = request.args.get('page', '')
      class_active = ' active' if query_string == uri else ''
      url = f"{get_config('site_url')}/{'' if get_config('pretty_uri') or uri == '' else '?page='}{uri}"

      nav_menu += f'<a href="{url}" title="{name}" class="item{class_active}">{name}</a>{sep}'

   return nav_menu.strip(sep)

def page_title():
   page = request.args.get('page', 'Home')
   return ' '.join(word.capitalize() for word in page.split('-'))

def page_content():
   page = request.args.get('page', 'home')
   path = os.path.join(os.getcwd(), get_config('content_path'), f'{page}.phtml')

   if not os.path.exists(path):
      path = os.path.join(os.getcwd(), get_config('content_path'), '404.phtml')

   with open(path, 'r') as file:
      return file.read()

def init():
   template_path = os.path.join(get_config('template_path'), 'template.html')
   with open(template_path, 'r') as file:
      return file.read()

  14. Erstelle die includes/functions.py-Datei, und lösche die vorhandene includes/functions.php-Datei.

  15. Der nächste Schritt in der Übersicht besteht darin, eine Flask-Anwendung zu erstellen. Bitte Copilot darum, dir dabei zu helfen:

    @workspace Set up a Flask application to handle routing and views, and map the routes to corresponding views. Tell me the location of any files that need to be created or changed.

    Copilot schlägt vor, eine Datei namens app.py im Stammverzeichnis des Projekts zu erstellen, die den folgenden Code enthält.

    Python
    from flask import Flask, render_template, request
import os

app = Flask(__name__)

config = {
   'name': 'Simple Python Website',
   'site_url': '',
   'pretty_uri': False,
   'nav_menu': {
      '': 'Home',
      'about-us': 'About Us',
      'products': 'Products',
      'contact': 'Contact',
   },
   'template_path': 'template',
   'content_path': 'content',
   'version': 'v3.1',
}

def get_config(key=''):
   return config.get(key, None)

@app.route('/')
@app.route('/<page>')
def index(page='home'):
   page_content = get_page_content(page)
   page_title = get_page_title(page)
   nav_menu = get_nav_menu()
   return render_template('template.html', page_title=page_title, page_content=page_content, nav_menu=nav_menu)

def get_page_title(page):
   return ' '.join(word.capitalize() for word in page.split('-'))

def get_page_content(page):
   path = os.path.join(os.getcwd(), get_config('content_path'), f'{page}.phtml')
   if not os.path.exists(path):
      path = os.path.join(os.getcwd(), get_config('content_path'), '404.phtml')
   with open(path, 'r') as file:
      return file.read()

def get_nav_menu(sep=' | '):
   nav_menu = ''
   nav_items = get_config('nav_menu')
   for uri, name in nav_items.items():
      query_string = request.args.get('page', '')
      class_active = ' active' if query_string == uri else ''
      url = f"{get_config('site_url')}/{'' if get_config('pretty_uri') or uri == '' else '?page='}{uri}"
      nav_menu += f'<a href="{url}" title="{name}" class="item{class_active}">{name}</a>{sep}'
   return nav_menu.strip(sep)

if __name__ == '__main__':
   app.run(debug=True)

    Copilot schlägt außerdem vor, template/template.php und template/template.html umzubenennen und die Datei so zu aktualisieren, dass die Jinja2-Vorlagensyntax verwendet wird:

    HTML
    
<!DOCTYPE html>
<html>
<head>
   <meta charset="utf-8" />
   <meta http-equiv="x-ua-compatible" content="ie=edge"/>
   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no"/>
   <title>{{ page_title }} | {{ get_config('name') }}</title>
   <link href="{{ get_config('site_url') }}/template/style.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div class="wrap">

   <header>
      <h1>{{ get_config('name') }}</h1>
      <nav class="menu">
         {{ nav_menu|safe }}
      </nav>
   </header>

   <article>
      <h2>{{ page_title }}</h2>
      {{ page_content|safe }}
   </article>

   <footer>
      <small>&copy;{{ get_config('version') }} {{ get_config('name') }}.<br>{{ get_config('version') }}</small>
   </footer>

</div>
</body>
</html>

  16. Erstelle die Dateien app.py und template/template.html wie vorgeschlagen.

  17. Möglicherweise schlägt Copilot auch vor, nach dem Erstellen dieser Dateien jetzt python app.py über das Stammverzeichnis des Repositorys im Terminal auszuführen und dann zu http://127.0.0.1:5000 zu navigieren.

    Note

    In Abhängigkeit von der Installation von Python auf deinem Computer musst du den Befehl python3 app.py anstelle von python app.py verwenden, um sicherzustellen, dass die richtige Python-Version verwendet wird.

    Hierbei werden Fehlermeldungen im Browser angezeigt.

  18. Kopiere die anfängliche TemplateNotFound-Fehlermeldung in die Copilot Chat-Ansicht, und frage nach, wie du dieses Problem beheben kannst. Zum Beispiel:

    @workspace When I run `python3 app.py`, I get the following error in the browser: `jinja2.exceptions.TemplateNotFound: template.html`. How can I fix this?

    Copilot antwortet, dass der Fehler darauf hinweist, dass Flask die template.html-Datei nicht finden kann.

    Copilot gibt an, dass Flask standardmäßig nach Vorlagen in einem Ordner namens templates im Stammverzeichnis deines Projekts sucht. Deine template.html-Datei befindet sich jedoch im template-Verzeichnis. Um dieses Problem zu beheben, musst du beim Erstellen der Flask-App den richtigen Vorlagenordner angeben. Das Tool empfiehlt, deine app.py-Datei zu aktualisieren und die Zuweisung app = Flask(__name__) so zu ändern, dass sie den template_folder-Parameter enthält:

    Python
    app = Flask(__name__, template_folder='template')

  19. Wenn der Flash-Bereitstellungsserver noch ausgeführt wird und du die Browserseite unter http://127.0.0.1:5000/ aktualisierst, wird nun ein neuer Fehler im Zusammenhang mit der get_config-Funktion angezeigt.

    Kopiere diese Fehlermeldung in die Copilot Chat-Ansicht, und bitte das Tool um Hilfe.

    @workspace When I run `python3 app.py`, I get the following error in the browser: `jinja2.exceptions.UndefinedError: 'get_config' is undefined.` How can I fix this?

    Copilot antwortet, dass der Fehler auftritt, da get_config im Jinja2-Vorlagenkontext nicht verfügbar ist. Du erhältst die Empfehlung, direkt vor der Zeile @app.route('/') den folgenden Code zur app.py-Datei hinzuzufügen:

    Python
    app.jinja_env.globals.update(get_config=get_config)

  20. Aktualisiere deinen Browser. Daraufhin sollte die Website angezeigt werden.

    Screenshot: „Simple Python Website“ ohne CSS-Formatierung

    Es werden jedoch keine CSS-Formatvorlagen angewendet. Dieses Problem wird als Nächstes behoben.

  21. Übermittle folgenden Prompt an Copilot:

    @workspace The deployed website does not use the CSS styles. How can I fix this?

    Copilot weist dich darauf hin, dass Flask deine CSS-Datei in einem Verzeichnis namens static erwartet. Das Tool schlägt vor, die vorhandene style.css-Datei aus dem template-Verzeichnis in ein neues static-Verzeichnis zu verschieben und anschließend den Pfad zur style.css-Datei innerhalb des head-Teils der template.html-Datei zu aktualisieren. Nimm die folgende Änderung vor:

    HTML
    
<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">

    Wenn du den Browser aktualisierst, sollte die Website jetzt ordnungsgemäß gerendert werden.

    Um die anfängliche Migration abzuschließen, führe die verbleibenden Schritte in der von Copilot übermittelten allgemeinen Übersicht aus, und bitte das Tool bei Bedarf um Hilfe.

Abschließen der Migration

Um den Migrationsprozess erfolgreich abzuschließen, sind die folgenden Schritte erforderlich:

  • Sorgfältiges Überprüfen der anfänglichen Migration
  • Bugfixes: Im hier beschriebenen Beispiel funktionieren die Seitenlinks beispielsweise nur, wenn du im config-Abschnitt der app.py-Datei pretty_uri auf True festlegst. Wenn du die Möglichkeit haben möchtest, Abfragezeichenfolgenparameter in den Seiten-URLs zu verwenden, oder wenn du diese Option aus dem Code entfernen möchtest, kannst du Copilot um Hilfe bei diesem Schritt bitten.
  • Schreibtests für das migrierte Projekt
  • Bereinigen des Projekts durch Entfernen aller Dateien, die nicht mehr benötigt werden
  • Umgestalten des Codes in der neuen Sprache. Durch den Migrationsprozess ist nun ein Python-Projekt verfügbar, dessen Architektur auf der Architektur des ursprünglichen PHP-Projekts basiert. Nachdem du die anfängliche Migration durchgeführt hast, kannst du jetzt den Code umgestalten, um die Features der Python-Sprache und des Flask-Frameworks optimal zu nutzen.
  • Aktualisieren der Dokumentation: Die readme.md-Datei ist jetzt veraltet und muss neu geschrieben werden.