In der heutigen Welt können Chatbots mit künstlicher Intelligenz wie ChatGPT und Claude viele Funktionen ausführen, beispielsweise das Verfassen von geschäftlichen E-Mails und die Planung von Reiserouten. Bei diesen Chatbots handelt es sich um Systeme, die auf großen Imaginative and prescient-Language-Modellen (VLMs) basieren: KI, die auf einem riesigen Datensatz trainiert wird, der Bücher, Web sites, Code und Bilder umfasst.

Die KI-Algorithmen werden dann anhand riesiger Mengen an von Menschen generiertem Suggestions verfeinert, um Anweisungen zu befolgen und schädliche oder unerwünschte Ausgaben zu vermeiden, und nutzen dieses „Wissen“, um Texte oder Bilder basierend auf den Eingaben eines Benutzers zu erstellen. Obwohl Chatbots klare Einschränkungen haben, können sie für eine Vielzahl von Aufgaben sehr hilfreich sein, auch in einigen Bereichen, die traditionell spezielle Fähigkeiten erfordern, wie etwa Computerprogrammierung.

Im Rahmen eines Projekts für die US-Luftwaffenministerium – MIT AI Accelerator‚S PhantomprogrammUS-Luftwaffenkadett Joshua Lynch – mit Hilfe seiner Mentorin Laura Niss, einer technischen Mitarbeiterin der Embedded- und KI-Systemgruppe am MIT Lincoln Laboratory – wollte herausfinden, ob er als völliger Programmieranfänger ein voll funktionsfähiges Programm entwickeln könnte. Er verwendete einen Prozess namens „Vibe-Coding“, bei dem sich ein Benutzer vollständig auf Eingabeaufforderungen verlässt, um einen generativen KI-Chatbot beim Schreiben und Verfeinern von Code anzuleiten.

Seine Motivation bestand darin, jeden, der mit dem militärischen Problemfeld vertraut ist, unabhängig von seinem technischen Hintergrund, in die Lage zu versetzen, seine Ideen für nützliche Softwareanwendungen voranzutreiben und dabei im Wesentlichen die Zeit- und Kostenbeschränkungen der traditionellen Entwicklungspipeline für militärische Software program zu umgehen. Lynch wollte seine eigene Anwendung entwickeln, während Niss seine Erfahrungen mit der Technologie überwachte.

„Der Phantom-Pupil wollte sehen, ob er ohne Vorkenntnisse eine nützliche Anwendung durch selbstidentifiziertes Vibe-Coding erstellen kann“, sagt Niss. „Im Rahmen dieses Projekts wollte ich verstehen, wie sich seine Wahrnehmung von KI im Laufe der Zeit mit der Nutzung veränderte. Wir wollten beide besser verstehen, wo und wie KI von nichttechnischen Benutzern im Militär eingesetzt werden kann.“

Lynch machte sich daran, herauszufinden, ob er ohne Programmierkenntnisse und mithilfe von Chatbots eine Anwendung speziell für seine Artwork von taktischem Workforce erstellen könnte, um Kollateralschäden zu reduzieren und gleichzeitig die Überlebensfähigkeit in der umfassenderen Mission zu verbessern. Diese Anwendung würde Funktionen bieten, darunter KI-gestützte Zielerkennung; modulare Intelligenz, Überwachung und Aufklärung; autonomes Schlagen; und Kommunikationsmanagement auf dem Schlachtfeld.

Während des Projekts absolvierte Lynch mehrere Fortbildungskurse im Bereich KI und machte sich mit den militärischen und nichtmilitärischen Einsatzmöglichkeiten der Technologie vertraut. Als Grundlage für seine Codegenerierung nutzte er die kostenpflichtigen Modelle von drei KI-Chatbots: Claude von Anthropic, ChatGPT von OpenAI und Gemini von Google. Der Großteil dieser Arbeit wurde nur über die Hauptchatfunktion der Chatbots in einem Webbrowser erledigt, nicht als integriertes System innerhalb einer Entwicklungsumgebung, wie es heute Customary ist. Die endgültige Anwendung wurde mit der Google AI Studio App erstellt, die Anwendungen erstellen kann, die mit der Gemini-Anwendungsprogrammierschnittstelle interagieren und über KI in die Entwicklungsumgebung integriert sind.

Drei Monate lang arbeitete Lynch mit diesen Modellen, um seine Anwendung namens „Distant Working Modular Augmentation System“ (ROMAD-AI) zu entwickeln. Während dieser Zeit lernte er verschiedene Methoden zur Verbesserung der Codeausgabe. Beispielsweise stieß er häufig auf Schwierigkeiten, weil den KI-Chatbots der hierarchische Fokus fehlte und sie nicht zusammenhängende Codeabschnitte modifizierten. Er entdeckte, dass es wichtig ist, Probleme in kleine Teile zu zerlegen, Fragen klar zu formulieren und Gespräche wieder auf das Thema zu lenken, wenn sie zu weit vom Ziel entfernt sind.

Den größten Teil der Projektzeit nahm das Erlernen der Grenzen der Chatbots ein und wie man sie effektiv umgeht. Als Lynch mehr Erfahrung mit den Chatbots sammelte, veranlassten ihn Einschränkungen bei den KI-Fähigkeiten und der Zeit für die Entwicklung dazu, den Umfang des Projekts zu ändern und es von einer Anwendung, die auf dem Schlachtfeld helfen konnte, auf eine umzustellen, die grundlegende Dokumentverarbeitung durchführen konnte, wie etwa die Analyse taktischer Karten von Schlachtfeldern und die Erstellung von Missionsplanungsdokumenten über eine Schnittstelle mit einem VLM-gestützten Chatbot. Obwohl der resultierende Prototyp nicht alle Funktionen erfüllte, die Lynch ursprünglich vorgesehen hatte (und in seiner aktuellen Model für den gewünschten Anwendungsfall nicht sicher struggle), bewies er die Leistungsfähigkeit und Nützlichkeit einer solchen Anwendung für Militärangehörige.

„Ich struggle von diesem Endprodukt ziemlich beeindruckt und es hat mir gezeigt, wie leistungsfähig diese Systeme beim Prototyping von Designs von Laien sein können“, sagt Niss. „Ich bin jetzt der Meinung, dass dies leistungsstarke Werkzeuge für nicht-technische Experten sein können, um technischen Experten Probleme und mögliche Lösungen zu vermitteln und bei der Kommunikation gewünschter Ergebnisse zu helfen.“

Niss beobachtete während seiner Erfahrung die Veränderung in Lynchs Sicht auf KI-Sprachmodelle. Nachdem Lynch mit einem beeindruckenden Ziel begonnen hatte, erlangte er ein Verständnis für die Möglichkeiten der aktuellen Technologie und schränkte seine Erwartungen bis zum Ende des Projektzeitraums deutlich ein. Messungen seiner Wahrnehmung der verschiedenen KI-Systeme im Laufe der Zeit und über Systemaktualisierungen hinweg waren für Lynch und Niss besonders interessant, wobei Claude in Bezug auf Merkmale wie Sympathie, Anthropomorphismus und wahrgenommene Intelligenz eine größere Stabilität zeigte als ChatGPT. Lynch empfand die KI als hilfreichen Nachhilfelehrer, bemerkte jedoch, dass sie bei Themen, die er intestine kannte, Ungenauigkeiten aufwies.

Das Projekt zeigte, dass KI-Chatbots nicht-technische Servicemitarbeiter in die Lage versetzen können, brauchbare Softwareanwendungen für ihre individuellen Probleme zu erstellen, obwohl sie beim Umgang mit sensiblen Informationen und für kritische Anwendungen besser als Prototyping-Assistent funktionieren als als vollständiges Produktionstool. Eine unsachgemäße Überprüfung des Codes kann zu Sicherheitsrisiken führen, wie ein Fall zeigt, bei dem Lynch nicht erkannte, dass die endgültige Anwendung die Eingabedokumente zur Analyse an ein Gemini-KI-Modell sendete, anstatt die Dokumente lokal auf seinem Laptop zu analysieren. Obwohl KI erhebliche Mengen an Funktionscode generieren kann, bleibt die Codeüberprüfung in diesem Bereich ein Engpass.

„Für mich hat dieses Projekt die Zusammenarbeit zwischen Experten in verschiedenen Bereichen gestärkt“, sagt Niss. „Egal wie intestine die KI wird, ich denke, wir müssen immer zusammenarbeiten, um die besten Lösungen für die wichtigsten Probleme zu finden.“

Die Forschung wurde vom Division of the Air Drive Synthetic Intelligence Accelerator gefördert und unter der Kooperationsvereinbarung Nr. FA8750-19-2-1000 durchgeführt.

Bild des Autors

# Einführung

Sie haben eine Weile in Python codiert, es absolut lieben und wahrscheinlich Dekorateure in Ihrem Schlaf schreiben. Aber es gibt diese nörgelnde Stimme in Ihrem Kopf, die sagt, dass Sie Typenkript lernen sollten. Vielleicht ist es für diese Vollstapelrolle, oder Sie sind es leid zu erklären, warum Python für große Codebasen „völlig in Ordnung“ ist.

Hier ist die Sache: TypeScript ist nicht nur „JavaScript mit Typen“. Es ist das, was JavaScript von Anfang an hätte sein sollen. Und wenn Sie aus Python kommen, verstehen Sie bereits mehr als Sie denken.

# Gehen Sie von Python zu Typscript

Python gibt Ihnen Enten -Typing und dynamische Flexibilität. TypeScript bietet Ihnen die gleiche Flexibilität mit einem Sicherheitsnetz. Denken Sie an als Pythons Mypy Wenn MyPy tatsächlich überall arbeitete.

In Python können Sie eine beliebige Methode für jedes Objekt aufrufen und „hoffen“, dass sie funktioniert. TypeScript teilt Sie zum Kompilierzeit mit, ob es funktionieren wird, und rettet Sie vor diesen "AttributeError: 'NoneType' object has no attribute 'identify'" Momente.

# Python: You hope this works
def process_user(consumer):
    return consumer.identify.higher()

// TypeScript: You already know this works
operate processUser(consumer: Person): string {
    return consumer.identify.toUpperCase();
}

Wenn consumer hat keine identify Eigenschaft, Typscript fängt es vor, bevor Ihr Code jemals ausgeführt wird. Sie brauchen additionally keine Verteidigung if hasattr(obj, 'attribute') Überall überall.

# Typscript -Grundlagen

Beginnen wir mit den Grundlagen von Typenkript.

// Variablen und Grundtypen

Pythons Typ -Hinweise sind optionale Vorschläge. Typscript -Typen sind eher erzwungene Verträge. Die guten Nachrichten? TypeScript kann die meisten Typen automatisch schließen, sodass Sie nicht alles mit Anmerkungen versehen müssen.

# Python
identify = "Alice"
age = 30
is_active = True
scores = (95, 87, 92)
consumer = {"identify": "Bob", "age": 25}

// TypeScript
const identify = "Alice";          // string (inferred)
const age = 30;                // quantity (inferred)
const isActive = true;         // boolean (inferred)
const scores = (95, 87, 92);   // quantity() (inferred)
const consumer = { identify: "Bob", age: 25 }; // object (inferred)

// Or be specific
const identify: string = "Alice";
const scores: quantity() = (95, 87, 92);

Sie benötigen nur explizite Anmerkungen, wenn die Inferenz nicht offensichtlich ist oder wenn Sie Ihre Absichten besonders klar machen möchten.

// Funktionen

Die Funktionssyntaxkarten karten quick direkt, aber der Ansatz von TypeScript zu Standardparametern ist sauberer als Pythons veränderliches Standardargument Gotchas.

# Python
def greet(identify: str, excited: bool = False) -> str:
    suffix = "!" if excited else "."
    return f"Hiya, {identify}{suffix}"

// TypeScript
operate greet(identify: string, excited = false): string {
    const suffix = excited ? "!" : ".";
    return `Hiya, ${identify}${suffix}`;
}

// Or arrow operate (Python lambda equal)
const greet = (identify: string, excited = false): string => 
    `Hiya, ${identify}${excited ? "!" : "."}`;

Die Pfeilfunktionssyntax ähnelt Pythons Lambda, aber mächtiger. Sie können vollständige Funktionskörper oder prägnante Einzeiler schreiben. Vorlagenliterale (diese Backticks) funktionieren genau wie Pythons F-Strings.

// Klassen

TypeScript -Klassen fühlen sich immer optimierter als Python -Klassen. Nicht mehr self Überall und Konstruktorparameter können automatisch zu Eigenschaften werden.

# Python
class Person:
    def __init__(self, identify: str, e mail: str):
        self.identify = identify
        self.e mail = e mail
    
    def greet(self) -> str:
        return f"Hello, I am {self.identify}"

// TypeScript
class Person {
    constructor(public identify: string, public e mail: string) {}
    
    greet(): string {
        return `Hello, I am ${this.identify}`;
    }
}

Das public Das Schlüsselwort im Konstruktor ist die Abkürzung von TypeScript für „Erstellen Sie diese Eigenschaft automatisch und weisen Sie ihm den Parameterwert zu.“ Sie müssen additionally die nicht benutzen self.identify = identify Kesselplatte. Sie können auch verwenden non-public oder protected zur Kapselung.

# Wo Typscript interessant wird

Hier fühlt sich TypeScript interessant an, wenn Sie über die Grundlagen hinausgehen.

// Gewerkschaftstypen (Python’s Union aber besser)

Pythons Gewerkschaftstypen aus der Schreibmodularbeit, aber manchmal ausführlich. Die Gewerkschaftstypen von TypeScript sind in die Sprache eingebaut.

# Python
from typing import Union
def process_id(user_id: Union(str, int)) -> str:
    return str(user_id)

// TypeScript
operate processId(userId: string | quantity): string {
    return userId.toString();
}

Der | Syntax ist sauberer als Union(str, int)Der Compiler von TypeScript kann eine ausgefeiltere Typüberprüfung durchführen. Es weiß, welche Methoden basierend auf dem spezifischen Typ zur Laufzeit verfügbar sind.

// Wörtliche Typen

Pythons wörtliche Typen sind relativ neu, aber hilfsbereit. TypeScript hat jedoch viel effektivere Wörteltypen.

# Python
from typing import Literal
Standing = Literal("pending", "authorized", "rejected")

def update_status(standing: Standing) -> None:
    print(f"Standing: {standing}")

// TypeScript
kind Standing = "pending" | "authorized" | "rejected";

operate updateStatus(standing: Standing): void {
    console.log(`Standing: ${standing}`);
}

Versuchen Sie, eine ungültige Zeichenfolge wie „vielleicht“ an zu übergeben updateStatusund Typscript weigern sich zu kompilieren. Ihr Editor bietet sogar automatische Vervollständigung für die gültigen Optionen. Es ist, als würde man eine Aufzählung haben, die tatsächlich nützlich ist.

// Schnittstellen

Pythons DataClasses eignen sich hervorragend zum Erstellen strukturierter Daten:

# Python
from dataclasses import dataclass

@dataclass
class Person:
    identify: str
    e mail: str
    age: int

Schnittstellen in TypeScript sind jedoch flexibler. Sie beschreiben die Daten, ohne eine bestimmte Klassenimplementierung zu erstellen.

// TypeScript
interface Person {
    identify: string;
    e mail: string;
    age: quantity;
}

// Use it anyplace
const consumer: Person = { identify: "Alice", e mail: "alice@instance.com", age: 30 };

Jedes Objekt, das die richtigen Eigenschaften hat, erfüllt automatisch die Schnittstelle. Keine Vererbung erforderlich, keine explizite Klassen -Instanziierung erforderlich. Es ist Enten, mit der Überprüfung der Kompilierung zu tippen.

# Weitere Typenkriptfunktionen lernen

Lassen Sie uns nun ein paar weitere nützliche Funktionen von TypeScript lernen.

// Generika (wie Pythons TypeVar)

Pythons generisches Tippen funktioniert, aber es ist klobig. Typscript Generics fühlt sich natürlich und mächtig an.

# Python
from typing import TypeVar, Listing
T = TypeVar('T')

def first(gadgets: Listing(T)) -> T:
    return gadgets(0)

// TypeScript
operate first(gadgets: T()): T {
    return gadgets(0);
}

// Works with something
const firstNumber = first((1, 2, 3));      // quantity
const firstString = first(("a", "b", "c"));  // string

Typscript färbt den generischen Typ automatisch von der Verwendung. Anruf first mit Zahlen, und es gibt eine Nummer zurück. Rufen Sie es mit Saiten an und es gibt eine Zeichenfolge zurück. Keine explizite Typparameter erforderlich, aber Sie können sie bereitstellen, wenn die Inferenz nicht klar ist.

// Geben Sie Wachen ein

Mit Typ Guards können Sie Laufzeitüberprüfungen schreiben, die der Compiler versteht und zum Eingrenzung von Typen in nachfolgenden Code verwendet.

operate isString(worth: unknown): worth is string {
    return typeof worth === "string";
}

operate processValue(worth: string | quantity) {
    if (isString(worth)) {
        return worth.toUpperCase();
    }
    return worth.toFixed(2);
}

Der worth is string Syntax sagt TypeScript, dass der Parameter definitiv eine Zeichenfolge ist, wenn diese Funktion true zurückgibt. Im IF -Block erhalten Sie vollständige Stringmethoden und Eigenschaften. Kein Casting, keine Behauptungen, nur ein intelligenter Typ verengen sich basierend auf Ihren Laufzeitüberprüfungen.

// Zugeordnete Typen (Listenverständnisse für Typen)

Stellen Sie sich kartierte Typen als Listenverständnis vor, aber für Typtransformationen. Sie können neue Typen erstellen, indem Sie vorhandene transformieren.

kind Person = {
    identify: string;
    e mail: string;
    age: quantity;
};

// Make all properties non-obligatory
kind PartialUser = Partial;

// Make all properties readonly
kind ReadonlyUser = Readonly;

// Decide particular properties
kind UserContact = Decide;

Diese Dienstprogrammtypen versenden mit TypeScript und lösen gemeinsame Muster. Wenn Sie einen Typ benötigen, der wie Benutzer, jedoch mit optionalen Feldern für Updates ist, können Sie verwenden Partial<Person>. Und wenn Sie nach der Erstellung keine Änderungen sicherstellen müssen, verwenden Sie die Verwendung Readonly<Person>.

# Fehlerbehandlung in TypeScript

Python -Entwickler lieben es, versuchen/außer Blöcken, aber sie können ausführlich werden. TypeScript verwendet einen anderen Ansatz mithilfe von Ergebnistypen und Gewerkschaftstypen für die Fehlerbehandlung, die Fehler in Ihren Funktionssignaturen explizit machen:

// Outcome kind sample (impressed by Rust)
kind Outcome = { success: true; information: T } | { success: false; error: E };

// Make this file a module
export {};

// Assuming you've got a Person kind and parseUser operate
interface Person {
    identify: string;
    // ... different properties
}

operate parseUser(information: unknown): Person {
    // Your parsing logic right here
    // This could throw an error if parsing fails
    if (!information || typeof information !== 'object') {
        throw new Error('Invalid consumer information');
    }
    
    const consumer = information as any;
    if (!consumer.identify || typeof consumer.identify !== 'string') {
        throw new Error('Person identify is required and have to be a string');
    }
    
    return { identify: consumer.identify };
}

async operate safeParseUser(information: unknown): Promise> {
    strive {
        const consumer = parseUser(information);
        return { success: true, information: consumer };
    } catch (error) {
        // Repair: Deal with the case the place error won't have a message property
        const errorMessage = error instanceof Error ? error.message : String(error);
        return { success: false, error: errorMessage };
    }
}

Sie können es so verwenden wie so:

// Utilization (wrapped in an async operate or use at prime stage in a module)
async operate instance() {
    const rawData = { identify: "John Doe" }; // Instance information
    const end result = await safeParseUser(rawData);

    if (end result.success) {
        console.log(end result.information.identify); // TypeScript is aware of that is Person
    } else {
        console.error(end result.error);   // TypeScript is aware of that is string
    }
}

// Name the instance operate
instance();

Dieses Muster macht Fehler im Typ des Typs explizit. Anstelle von Ausnahmen, die unsichtbar herumfliegen, werden Fehler Teil des Rückkehrtyps. Der Outcome<T, E> Typ zwingt Sie dazu, sowohl Erfolg als auch Misserfolg zu bewältigen. Die diskriminierten Gewerkschaften von TypeScript machen dieses Muster einfach: Die Erfolgseigenschaft zeigt an, in welcher Gewerkschaft Sie sich befinden, sodass es weiß, ob Daten oder Fehler verfügbar sind.

# Abschluss

Typscript wird in Webentwicklung, groß angelegten Anwendungen und überall, wo Sie robuste APIs benötigen.

Bei dem Übergang geht es nicht darum, eine neue Sprache zu lernen. Es geht mehr darum, alles, was Sie über gutes Softwaredesign wissen, in einem anderen Ökosystem anzuwenden. Ihre Python -Instinct für sauberes Code, lesbare APIs und nachdenkliche Abstraktionen übersetzt direkt.

Additionally öffnen Sie vs Code, erstellen Sie a .ts Datei und mit dem Codieren beginnen. Das Schlimmste, was passiert? Sie lernen etwas Neues. Das Beste? Möglicherweise finden Sie Ihre neue Lieblingssprache. Pleased Coding!

Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Information Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.