xAI hat einen neuen Modus ausgeliefert angerufen /aim im Grok Constructsein terminaler Codierungsagent. Die Funktion zielt auf eine lang andauernde, autonome Aufgabenausführung ab. Sie übergeben dem Agenten eine größere Implementierungsaufgabe und treten dann einen Schritt zurück.

Die meisten Codierungssitzungen erfordern eine hin- und hergehende Ausführung und Überprüfung. Sie fragen nach, der Agent handelt und Sie überprüfen jeden Schritt. /aim ändert diese Schleife. Der Agent arbeitet weiter, bis eine Aufgabe abgeschlossen und überprüft ist. Bei der Verifizierung kann es sich um die Überprüfung von Code, die Inspektion von Webseiten oder die Ausführung von Skripts handeln.

Der Modus bündelt diese Autonomie hinter einem Befehl und einer sichtbaren Fortschrittscheckliste.

TL;DR

• /aim führt lange, autonome Aufgaben im Terminalagenten von Grok Construct aus.
• Es plant einen Ansatz, erstellt eine Checkliste, führt sie aus und überprüft sie bis zur Fertigstellung.
• Durch die Verifizierung kann Code überprüft, Webseiten untersucht oder Skripte ausgeführt werden.
• standing, pause, resumeUnd clear den Reside-Lauf steuern.
• Für den Zugriff ist ein SuperGrok- oder X Premium Plus-Abonnement erforderlich.

Was ist /aim

/aim ist ein Modus innerhalb von Grok Construct, kein separates Produkt. Grok Construct ist der Codierungsagent und die CLI von xAI für die Softwareentwicklung. Eine CLI ist ein Befehlszeilentool, das in Ihrem Terminal ausgeführt wird. Es arbeitet mit Ihrer lokalen Codebasis, liest Dateien und führt Befehle aus.

Grok Construct bietet bereits mehrere Agentenfunktionen. Es verfügt über einen Planmodus, der Änderungen blockiert, bis Sie einen Plan genehmigen. Es delegiert größere Arbeiten an spezialisierte Subagenten, die parallel ausgeführt werden. Es liest Ihr AGENTS.mdPlugins, Hooks, Abilities und MCP-Server sofort einsatzbereit. MCP ist ein Protokoll, das Agenten mit externen Instruments und Daten verbindet.

Für den Zugriff ist ein SuperGrok- oder X Premium Plus-Abonnement erforderlich. Sie installieren die CLI mit einem Befehl:

curl -fsSL https://x.ai/cli/set up.sh | bash

Anschließend melden Sie sich mit Ihrem Konto an und rufen auf /aim. Der Modus ist für die Übergabe konzipiert. Sie beschreiben ein Ziel und der Agent ist für die mehrstufige Arbeit verantwortlich.

Warum eine langfristige Ausführung wichtig ist

Einem Agenten wird ein Ziel vorgegeben, nicht nur eine einzelne Aufforderung. Es plant Schritte, führt sie aus, beobachtet Ergebnisse und plant neu, wenn die Realität davon abweicht. Das ist die Beobachten-Plan-Handeln-Schleife. Der Kompromiss besteht in der Beobachtbarkeit: Lange Läufe führen zu vielen Aktionen, die Sie überwachen müssen. /aim antwortet darauf mit einer Fortschritts-Checkliste und Lenkbefehlen.

Wie /aim Funktioniert

Sie setzen sich in einer einzigen Zeile ein Ziel. Sie geben es in der Grok Construct-Sitzung ein, nicht in Ihrer System-Shell. Zum Beispiel:

/aim Migrate the auth module to the brand new API

Grok Construct plant einen Ansatz für dieses Ziel. Es unterteilt die Arbeit in eine Fortschrittscheckliste. Anschließend werden die Checklistenelemente nacheinander ausgeführt.

Sie sind während des Laufs nicht ausgesperrt. Sie können weitere Anweisungen weitergeben, während es funktioniert. Wenn das Ziel erreicht ist, dreht sich das Panel um Vollständig. Jeder Checklistenpunkt wird dann als geprüft angezeigt.

Der Verifizierungsschritt

Das erwähnenswerte Element ist die Überprüfung. /aim hört nicht beim Schreiben von Code auf. Dies wird fortgesetzt, bis die Aufgabe abgeschlossen und überprüft ist.

Die Verifizierung kann laut xAI drei Formen annehmen. Der Agent kann den von ihm erstellten Code überprüfen. Es kann Webseiten untersuchen, um das Verhalten zu bestätigen. Es kann Skripte ausführen, um das Ergebnis zu testen.

Dies ist für autonome Läufe wichtig. Ein Agent, der nur Dateien bearbeitet, meldet möglicherweise einen Erfolg, bevor die Änderung wirksam wird. Wenn Sie die Überprüfung in den Lauf einbauen, testet der Agent seine eigene Ausgabe, bevor er abgeschlossen ist.

Interaktive Demo

Anwendungsfälle mit Beispielen

Das Hauptbeispiel ist die Modulmigration. /aim Migrate the auth module to the brand new API deckt eine Änderung mehrerer Dateien ab. Die Aufgabe ist langwierig, mechanisch und testbar.

Andere praktische Übergaben passen in die gleiche Kind:

• Refaktorieren Sie einen Dienst und führen Sie dann seine Testsuite aus, um einen grünen Construct zu bestätigen.
• Fügen Sie einen Endpunkt hinzu und überprüfen Sie dann die gerenderte Seite auf Laufzeitfehler.
• Aktualisieren Sie eine Abhängigkeit, führen Sie den Construct aus und beheben Sie die Fehler.
• Portieren Sie eine Konfiguration dateiübergreifend und führen Sie dann ein Skript aus, um sie zu validieren.

Jede Aufgabe passt besser zu einem autonomen Ziel als eine schnelle einzeilige Bearbeitung. Der Erfolg stellt sich ein, wenn die Arbeit viele Schritte umfasst, die Sie sonst überwachen würden.

Ein langfristiges Ziel steuern

/aim fügt Befehle zur Überwachung und Steuerung des Laufs hinzu. Sie geben sie in der Grok Construct-Sitzung ein:

/aim standing     # see the reside progress panel
/aim pause      # cease work, maintain the aim
/aim resume     # decide again up
/aim clear      # drop the aim completely

standing zeigt das Reside-Fortschrittsfenster an. pause unterbricht die Arbeit, hält aber das Ziel aufrecht. resume macht dort weiter, wo es aufgehört hat. clear lässt das Ziel ganz fallen und fängt neu an.

Diese Kontrollen sind wichtig für unbeaufsichtigte Läufe. Sie können die Arbeit jederzeit unterbrechen oder das Ziel aufgeben. Das ist hilfreich, wenn ein Agent selbst Dateien bearbeitet und Skripte ausführt.

Wie /aim Vergleicht

/aim gehört zu den Terminal-Coding-Agenten, die bereits mehrstufige Arbeiten ausführen. Was es hinzufügt, ist ein explizites, steuerbares Zielobjekt. Die benannten Lebenszyklusbefehle und der integrierte Überprüfungsschritt sind die neuen Teile.

Wichtige Erkenntnisse

• /aim führt lange, autonome Aufgaben im Terminalagenten von Grok Construct aus.
• Es plant einen Ansatz, erstellt eine Checkliste, führt sie aus und überprüft sie bis zur Fertigstellung.
• Durch die Verifizierung kann Code überprüft, Webseiten untersucht oder Skripte ausgeführt werden.
• standing, pause, resumeUnd clear den Reside-Lauf steuern.
• Für den Zugriff ist ein SuperGrok- oder X Premium Plus-Abonnement erforderlich.

Schauen Sie sich das an Technische Particulars. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 150k+ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Möchten Sie mit uns zusammenarbeiten, um Ihr GitHub-Repo ODER Ihre Hugging Face Web page ODER Produktveröffentlichung ODER Ihr Webinar usw. zu bewerben? Vernetzen Sie sich mit uns

Michal Sutter ist ein Information-Science-Experte mit einem Grasp of Science in Information Science von der Universität Padua. Mit einer soliden Grundlage in statistischer Analyse, maschinellem Lernen und Datentechnik ist Michal hervorragend darin, komplexe Datensätze in umsetzbare Erkenntnisse umzuwandeln.

Die Wall Avenue ist dabei, etwas zu besitzen, was sie noch nie zuvor gesehen hat

Am 11. Juni wird SpaceX seinen Börsengang mit 135 US-Greenback professional Aktie bepreisen. Drei Tage später werden öffentliche Investoren einen Teil des ungewöhnlichsten Technologieunternehmens besitzen, das seit einer Technology an die Börse geht. Sie werden Raketen, Satelliten-Breitband, eine Social-Media-Plattform, bahnbrechende KI-Modelle und eine unbewiesene Imaginative and prescient von Datenzentren im Orbit der Erde besitzen.

Was sie auch besitzen werden, ist ein Gründer, der nach dem Angebot 82,4 % der Stimmrechte kontrolliert.

Das ist die wahre Geschichte. Nicht die Kapitalerhöhung in Höhe von 75 Milliarden US-Greenback. Nicht die Bewertung von 1,75 Billionen US-Greenback. Nicht einmal das explosive Wachstum von Starlink. Die Geschichte ist, was das öffentliche Debüt von SpaceX über die Kontrolle von Gründern in einer Zeit enthüllt, in der öffentliche Märkte vierteljährliche Sicherheit und Gründer jahrzehntelange Autonomie verlangen.

Die Architektur, die SpaceX ungewöhnlich macht

SpaceX erwarb xAI Holdings im Februar 2026. Innerhalb von xAI saß X Holdings Corp., die Muttergesellschaft von

Anleger, die SPCX-Aktien kaufen, besitzen alles gleichzeitig: Falcon und Dragon starten den Betrieb. Starlink mit 10,3 Millionen Abonnenten, die im Jahresvergleich um 105 % wachsen. Starshield, der Konnektivitätsdienst der Regierung. Grok, das KI-Modell, das auf der Recheninfrastruktur von xAI trainiert wurde. X, wodurch Werbe-, Abonnement- und Datenlizenzeinnahmen generiert werden. Und orbitale Rechenzentren, die eine Zukunftswette bleiben, kein aktuelles Geschäft.

Die konsolidierten Finanzzahlen für 2025 weisen einen Umsatz von 18,7 Milliarden US-Greenback aus. Das erste Quartal 2026 verzeichnete einen Umsatz von 4,7 Milliarden US-Greenback und einen Nettoverlust von 4,3 Milliarden US-Greenback. Dieser Verlust ist erheblich. Es spiegelt wider, was passiert, wenn ein kapitalintensives Luft- und Raumfahrtunternehmen mit einem KI-Startup zusammenarbeitet, das vierteljährlich 3,5 Milliarden US-Greenback für Forschung und Entwicklung ausgibt. Das Unternehmen ist unrentabel und der IPO-Prospekt verspricht keine kurzfristige Rentabilität.

Analyse: Die Finanzstruktur von SpaceX wirft eine Frage auf, mit der sich die meisten börsennotierten Unternehmen nicht auseinandersetzen müssen. Wie lange werden öffentliche Aktionäre neben einem profitablen Satelliten-Breitbandgeschäft eine verlustbringende KI-Infrastruktur und spekulatives Orbital-Computing finanzieren? Traditionelle Technologieunternehmen haben diese Frage mit einer Spaltung beantwortet: OpenAI und Microsoft sind separate Einheiten. Google und Alphabet sind konsolidiert, verfügen jedoch über unterschiedliche Umsatzberichte. SpaceX entschied sich für eine Konsolidierung ohne Teilung und zwang die Anleger, die Stärke von Starlink im Vergleich zur Burn-Fee von xAI als Einzelaktie zu bewerten.

Die Starlink-KI-Spannung ist der tragende Konflikt

Starlink ist die Engine für wiederkehrende Einnahmen. Mit monatlichen Verbraucherplänen ab 120 US-Greenback und Geschäftskonnektivitätsverträgen, die Luftfahrt-, See- und Regierungsdienste umfassen, generiert Starlink einen vorhersehbaren Cashflow. Es ist das einzige Section von SpaceX, das zu den aktuellen Bewertungen unabhängig investierbar wäre.

Dieser Vorteil geht mit einer Einschränkung einher. Starlink fungiert auch als interner Kunde für die Startkapazität von SpaceX. Jeder von SpaceX eingesetzte Satellit ist ein Begin, der Dritteinnahmen hätte generieren können. Das Administration gab bekannt, dass das Raumfahrtsegment langsamer wachsen wird als der Gesamtumsatz des Unternehmens, gerade weil die interne Infrastruktur einen wachsenden Anteil der verfügbaren Flugkapazität beansprucht. Das Wachstum von Starlink wird teilweise durch den Verzicht auf kommerzielle Starteinnahmen finanziert.

Grok steht vor einem anderen wirtschaftlichen Drawback. xAI meldete Betriebsverluste. Die Kosten für die Computing-Infrastruktur steigen schneller, als KI-Umsatzmodelle nachweislich unterstützen können. Für das Coaching von Grenzmodellen sind GPUs, Strom, Kühlung und Netzwerke in großem Maßstab erforderlich. Grok-Abonnements und X-Werbeeinnahmen haben noch keinen klaren Weg zur Deckung dieser Kosten geschaffen. Das Unternehmen geht davon aus, dass Größe und Differenzierung die Lücke letztendlich schließen werden. Das ist keine Garantie.

Meinung: Die Spannung wird bei der Untersuchung deutlich. Das Abonnentenwachstum und die Margen von Starlink können einige der Ambitionen von SpaceX finanzieren. Sie können nicht alle gleichzeitig finanzieren. Die Entwicklung von Raumschiffen erfordert nachhaltiges Kapital. Orbitale Rechenzentren würden Startkapazität erfordern, die Starlink bereits verbraucht. Der Infrastrukturausbau von xAI konkurriert mit Hardwareprojekten um Kapital und technische Talente. Öffentliche Anteilseigner finanzieren eine strategische Drei-Wege-Wette, und die Allokationsentscheidungen des Managements werden darüber entscheiden, ob sie funktioniert oder scheitert. Die Fehlerquote ist hauchdünn.

Gründerkontrolle als Governance-Funktion, nicht als Warnung

Musk wird nach dem Börsengang 82,4 % der Stimmrechte behalten. Reuters meldete diese Zahl anhand von Prospektdaten. Das bedeutet, dass öffentliche Aktionäre über wirtschaftliches Engagement verfügen, ohne nennenswerten Einfluss auf die strategische Ausrichtung zu haben.

Diese Regelung beunruhigt einige Anleger. Sie betrachten die Gründerkontrolle als Governance-Risiko. Im SpaceX-Prospekt wird es als Ausrichtung bezeichnet. Musks Privatvermögen ist an das Unternehmen gebunden. Sein Ruf ist mit den Ergebnissen von SpaceX verknüpft. Seine Kontrolle stellt sicher, dass ein öffentlicher Vorstand ihn nicht dazu drängen kann, langfristige Projekte für kurzfristige Einnahmen zu opfern.

Analyse: Die Daten unterstützen dieses Framing. Die technischen Erfolge von SpaceX im Privatbesitz sind messbar. Die Missionserfolgsquote von Falcon 9 von über 99 %, die durch nachhaltige Kapitalinvestitionen und technische Konzentration erreicht wird, wäre nicht gegeben, wenn der vierteljährliche Ertragsdruck Kostensenkungen erzwungen hätte. Das Flugtestprogramm von Starship würde nicht in seinem derzeitigen Tempo voranschreiten, wenn ein öffentlicher Vorstand zuerst die Rentabilität fordern würde.

Meinung: Die Frage, mit der sich der Markt konfrontiert sieht, ist, ob diese Erfolgsbilanz auf öffentliches Eigentum übergeht. Werden die Märkte vierteljährliche Verluste in Höhe von 3,5 Milliarden US-Greenback bei der KI-Infrastruktur tolerieren? Werden Anleger Entscheidungen über die Kapitalallokation akzeptieren, die eher von langfristigen Visionen als von vierteljährlichen Renditen geleitet werden? Musks Kontrolle stellt sicher, dass die Antwort für die ersten Jahre von SpaceX „Ja“ lautet. Was passiert, wenn stimmberechtigte Aktionäre es satt haben, spekulative Wetten zu subventionieren? Das ist die Prüfung, vor der der Börsengang nach den ersten 18 Handelsmonaten stehen wird.

Die Bewertungspreise in Jahren unbewiesener Ausführung

Morningstar schätzte den fairen Wert von SpaceX auf etwa 780 Milliarden US-Greenback. Der Börsengang kostet 1,75 Billionen US-Greenback. Die Lücke ist kein Bewertungsunterschied. Es handelt sich um eine Aussage darüber, welche Wetten sich nach Ansicht eines Anlegers auszahlen werden.

Die Roadshow von SpaceX argumentiert, dass das Unternehmen einzigartig positioniert ist, um sowohl Spitzen-KI als auch startabhängige Infrastruktur anzuführen. Dabei handelt es sich um eine Behauptung des Unternehmens, nicht um einen unabhängig überprüften Vorteil. OpenAI, Google, Meta und Anthropic bauen alle große Rechenkapazitäten auf. Keiner von ihnen verfügt über Startkapazitäten. SpaceX verfügt über Startkapazitäten und baut Rechenleistung auf. Ob diese vertikale Integration einen vertretbaren Vorteil schafft oder SpaceX lediglich dazu zwingt, in zwei konkurrierenden Unternehmen härter zu agieren, bleibt ungewiss.

Orbitale Rechenzentren sind das größte spekulative Ingredient. Der Prospekt stellt sie als zukünftige Probability dar. Sie erwirtschaften derzeit keine Einnahmen. Weltraumtaugliche Prozessoren hinken terrestrischen Chips hinterher. Strahlungsschäden und Wärmeabgabe im Orbit stellen ungelöste technische Herausforderungen dar. Die Markteinführungsökonomie muss deutlich verbessert werden. Die Regulierungsbehörden können die Nutzung von Trümmern in der Umlaufbahn und des Spektrums prüfen. Der Zeitplan für den kommerziellen Betrieb könnte weit über die in der aktuellen Bewertung enthaltenen Fünfjahresprognosen hinausgehen.

Analyse: Nichts davon macht den Börsengang von SpaceX irrational. Das Wachstum von Starlink ist actual. Die Markteinführungsökonomie verbessert sich. Der Bedarf an KI-Infrastruktur ist actual. Die Frage ist, ob worthwhile, wiederkehrende Operationen spekulative Projekte mit langer Laufzeit finanzieren und gleichzeitig das Vertrauen der Anleger über Marktzyklen und unvermeidliche Rückschläge hinweg bewahren können.

Meinung: Das erste Jahr des öffentlichen Handels von SpaceX wird nicht nur die Begeisterung der Anleger auf die Probe stellen. Es wird getestet, ob die Gründerkontrolle in einem öffentlichen Unternehmen mit der Volatilität, die die Grenztechnologie erfordert, koexistieren kann. Wenn sich die Aktie trotz eines Ausfalls von Starship oder eines vierteljährlichen Verlustanstiegs als widerstandsfähig erweist, wird die IPO-Struktur zu einem Modell, das andere Gründer zu kopieren versuchen. Wenn öffentliche Aktionäre rebellieren, wird dies zu einer warnenden Geschichte über die Grenzen der Stimmrechte der Gründer.

Was am Rande passiert

Nach Handelsbeginn sollten Anleger das Abonnentenwachstum und die Preisgestaltung von Starlink im Auge behalten. Beobachten Sie, ob der Umsatz von xAI in Richtung seiner Burn-Fee steigt. Beobachten Sie die Flugfrequenz und kommerzielle Einsatzbereitschaft von Starship. Beobachten Sie, ob sich Musks Stimmkontrolle in strategischer Geduld niederschlägt oder in Entscheidungen, die die Rendite der Aktionäre zugunsten einer persönlichen Imaginative and prescient opfern.

Der Preis für den Börsengang setzt voraus, dass alles wie geplant funktioniert. Die Geschichte zeigt, dass nicht alles so sein wird. Das Unternehmen, das Rückschläge mit intakter Unterstützung der Aktionäre übersteht, wird die eigentliche Frage beantwortet haben: Können öffentliche Märkte ein vom Gründer kontrolliertes Unternehmen tolerieren, bei dem die Umsetzung Vorrang vor dem Gewinn hat?

class RoutedAgent:
   def __init__(self, server: MCPToolServer, router: HybridMCPRouter, mannequin: str):
       self.server = server
       self.router = router
       self.mannequin = mannequin


   def discover_exposed_tools(self, exposed_tool_names: Record(str)) -> Record(Dict(str, Any)):
       return (t for t in self.server.tools_list() if t("title") in exposed_tool_names)


   def plan(self, activity: str, exposed_tools: Record(Dict(str, Any))) -> PlanOutput:
       directions = """
You're a planning agent in an MCP-like structure.
You possibly can solely use the uncovered instruments.
Resolve whether or not instruments are wanted.
Return strict JSON solely with keys:
requires_tools: boolean
tool_calls: array of objects with tool_name and arguments
direct_answer_allowed: boolean
planner_note: string


Guidelines:
- Use at most 3 device calls.
- Solely name instruments from the uncovered listing.
- Arguments should match every device's enter schema conceptually.
- Desire calling vector_retrieve for conceptual native data.
- Desire calling web_search for latest or exterior info.
- Desire dataset_loader if the person asks a couple of named built-in dataset.
- Desire python_exec solely when computation or code execution is genuinely helpful.
- Don't fabricate unavailable instruments.
"""


       immediate = f"""
USER TASK:
{activity}


EXPOSED TOOLS:
{json.dumps(exposed_tools, indent=2)}


Return JSON solely.
"""
       obj = llm_json(directions, immediate)


       raw_tool_calls = obj.get("tool_calls", ())
       parsed_calls = ()
       allowed = {t("title") for t in exposed_tools}


       for name in raw_tool_calls(:MAX_TOOL_CALLS):
           title = name.get("tool_name", "")
           args = name.get("arguments", {})
           if title in allowed and isinstance(args, dict):
               parsed_calls.append(ToolCall(tool_name=title, arguments=args))


       return PlanOutput(
           requires_tools=bool(obj.get("requires_tools", False) or parsed_calls),
           tool_calls=parsed_calls,
           direct_answer_allowed=bool(obj.get("direct_answer_allowed", False)),
           planner_note=obj.get("planner_note", ""),
       )


   def run_tools(self, tool_calls: Record(ToolCall)) -> Record(ToolResult):
       outcomes = ()
       for tc in tool_calls:
           outcome = self.server.tools_call(tc.tool_name, tc.arguments)
           outcomes.append(outcome)
       return outcomes


   def reply(self, activity: str, route: RouteDecision, exposed_tools: Record(Dict(str, Any)), plan: PlanOutput, outcomes: Record(ToolResult)) -> str:
       directions = """
You're the closing answering agent in an MCP-style routed device system.
Use the routed instruments and returned device outputs to reply the person.
Be concrete, concise, and technically appropriate.
If device outputs are partial, say so.
Don't point out hidden instruments that weren't uncovered.
"""


       tool_result_payload = (r.model_dump() for r in outcomes)


       immediate = f"""
USER TASK:
{activity}


ROUTE DECISION:
{route.model_dump_json(indent=2)}


EXPOSED TOOLS:
{json.dumps(exposed_tools, indent=2)}


PLAN:
{plan.model_dump_json(indent=2)}


TOOL RESULTS:
{json.dumps(tool_result_payload, indent=2)}


Now reply the person clearly.
"""
       resp = consumer.responses.create(
           mannequin=self.mannequin,
           enter=immediate,
           directions=directions,
           temperature=0.2
       )
       return resp.output_text


   def run(self, activity: str, verbose: bool = True) -> Dict(str, Any):
       route = self.router.route(activity)
       exposed_tools = self.discover_exposed_tools(route.selected_tools)
       plan = self.plan(activity, exposed_tools)
       outcomes = self.run_tools(plan.tool_calls) if plan.requires_tools else ()
       final_answer = self.reply(activity, route, exposed_tools, plan, outcomes)


       payload = {
           "activity": activity,
           "route_decision": route.model_dump(),
           "exposed_tools": exposed_tools,
           "plan": plan.model_dump(),
           "tool_results": (r.model_dump() for r in outcomes),
           "final_answer": final_answer,
       }


       if verbose:
           console.print(Panel.match(f"USER TASKn{activity}", title="Enter"))
           pretty_tools_table(exposed_tools, "Instruments Uncovered By MCP Router")
           console.print(Panel(route.rationale or "No rationale supplied", title="Router Rationale"))
           if route.policy_notes:
               console.print(Panel("n".be a part of(f"- {x}" for x in route.policy_notes), title="Coverage Notes"))
           console.print(Panel(plan.planner_note or "No planner word supplied", title="Planner Observe"))


           if outcomes:
               for r in outcomes:
                   console.print(Panel.match(RichJSON.from_data(r.model_dump()), title=f"Software End result: {r.tool_name}"))
           console.print(Panel(final_answer, title="Last Reply"))


       return payload


def mcp_jsonrpc_tools_list(server: MCPToolServer) -> Dict(str, Any):
   return {
       "jsonrpc": "2.0",
       "id": 1,
       "outcome": {
           "instruments": server.tools_list()
       }
   }


def mcp_jsonrpc_tools_call(server: MCPToolServer, tool_name: str, arguments: Dict(str, Any)) -> Dict(str, Any):
   outcome = server.tools_call(tool_name, arguments)
   return {
       "jsonrpc": "2.0",
       "id": 2,
       "outcome": outcome.model_dump()
   }


router = HybridMCPRouter(server=server, mannequin=MODEL)
agent = RoutedAgent(server=server, router=router, mannequin=MODEL)


console.print(Panel.match("MCP-STYLE TOOL DISCOVERY", title="Step 1"))
console.print(RichJSON.from_data(mcp_jsonrpc_tools_list(server)))


demo_tasks = (
   "Clarify how an MCP device router ought to expose instruments for an agent activity about dynamic functionality publicity.",
   "Search the online for latest examples of MCP-related developments and summarize them.",
   "Load the iris dataset, examine its columns and primary stats, and inform me what sort of ML drawback it's.",
   "Retrieve native data about context injection and router insurance policies, then clarify why proscribing device entry helps agent efficiency.",
   "Use Python to compute the typical of (3, 5, 9, 10, 13) after which clarify whether or not python execution was actually crucial.",
)


all_runs = ()
for idx, activity in enumerate(demo_tasks, begin=1):
   console.print(Panel.match(f"DEMO RUN {idx}", title="=" * 10))
   out = agent.run(activity, verbose=True)
   all_runs.append(out)


custom_task = "Design a routed MCP workflow for an AI analysis assistant that ought to use retrieval for native protocol data and net search solely when the duty explicitly asks for latest info."
custom_run = agent.run(custom_task, verbose=True)


print("nPROGRAMMATIC EXAMPLE: instruments/listing")
print(json.dumps(mcp_jsonrpc_tools_list(server), indent=2))


print("nPROGRAMMATIC EXAMPLE: instruments/name for vector_retrieve")
print(json.dumps(mcp_jsonrpc_tools_call(server, "vector_retrieve", {"question": "dynamic functionality publicity in MCP routers", "top_k": 2}), indent=2))


print("nPROGRAMMATIC EXAMPLE: instruments/name for dataset_loader")
print(json.dumps(mcp_jsonrpc_tools_call(server, "dataset_loader", {"title": "iris", "n_rows": 5}), indent=2))


print("nPROGRAMMATIC EXAMPLE: customized closing reply")
print(custom_run("final_answer"))

In diesem Tutorial erstellen wir einen selbstverifizierenden DataOps AIAgent, der Datenoperationen mithilfe lokaler Hugging Face-Modelle automatisch planen, ausführen und testen kann. Wir entwerfen den Agenten mit drei intelligenten Rollen: einem Planer, der eine Ausführungsstrategie erstellt, einem Executor, der Code mit Pandas schreibt und ausführt, und einem Tester, der die Ergebnisse auf Genauigkeit und Konsistenz validiert. Durch die lokale Verwendung des Phi-2-Modells von Microsoft in Google Colab stellen wir sicher, dass der Workflow effizient, reproduzierbar und datenschutzkonform bleibt, und demonstrieren gleichzeitig, wie LLMs komplexe Datenverarbeitungsaufgaben durchgängig automatisieren können. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip set up -q transformers speed up bitsandbytes scipy
import json, pandas as pd, numpy as np, torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline, BitsAndBytesConfig


MODEL_NAME = "microsoft/phi-2"


class LocalLLM:
   def __init__(self, model_name=MODEL_NAME, use_8bit=False):
       print(f"Loading mannequin: {model_name}")
       self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
       if self.tokenizer.pad_token is None:
           self.tokenizer.pad_token = self.tokenizer.eos_token
       model_kwargs = {"device_map": "auto", "trust_remote_code": True}
       if use_8bit and torch.cuda.is_available():
           model_kwargs("quantization_config") = BitsAndBytesConfig(load_in_8bit=True)
       else:
           model_kwargs("torch_dtype") = torch.float32 if not torch.cuda.is_available() else torch.float16
       self.mannequin = AutoModelForCausalLM.from_pretrained(model_name, **model_kwargs)
       self.pipe = pipeline("text-generation", mannequin=self.mannequin, tokenizer=self.tokenizer,
                            max_new_tokens=512, do_sample=True, temperature=0.3, top_p=0.9,
                            pad_token_id=self.tokenizer.eos_token_id)
       print("✓ Mannequin loaded efficiently!n")


   def generate(self, immediate, system_prompt="", temperature=0.3):
       if system_prompt:
           full_prompt = f"Instruct: {system_prompt}nn{immediate}nOutput:"
       else:
           full_prompt = f"Instruct: {immediate}nOutput:"
       output = self.pipe(full_prompt, temperature=temperature, do_sample=temperature>0,
                          return_full_text=False, eos_token_id=self.tokenizer.eos_token_id)
       outcome = output(0)('generated_text').strip()
       if "Instruct:" in outcome:
           outcome = outcome.break up("Instruct:")(0).strip()
       return outcome

Wir installieren die erforderlichen Bibliotheken und laden das Phi-2-Modell lokal mithilfe von Hugging Face Transformers. Wir erstellen eine LocalLLM-Klasse, die den Tokenizer und das Modell initialisiert, optionale Quantisierung unterstützt und eine Generiermethode definiert, um Textausgaben zu erzeugen. Wir stellen sicher, dass das Modell sowohl auf der CPU als auch auf der GPU reibungslos läuft, sodass es sich superb für den Einsatz auf Colab eignet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

PLANNER_PROMPT = """You're a Information Operations Planner. Create an in depth execution plan as legitimate JSON.


Return ONLY a JSON object (no different textual content) with this construction:
{"steps": ("step 1","step 2"),"expected_output":"description","validation_criteria":("standards 1","standards 2")}"""


EXECUTOR_PROMPT = """You're a Information Operations Executor. Write Python code utilizing pandas.


Necessities:
- Use pandas (imported as pd) and numpy (imported as np)
- Retailer remaining end in variable 'outcome'
- Return ONLY Python code, no explanations or markdown"""


TESTER_PROMPT = """You're a Information Operations Tester. Confirm execution outcomes.


Return ONLY a JSON object (no different textual content) with this construction:
{"handed":true,"points":("any points discovered"),"suggestions":("recommendations")}"""


class DataOpsAgent:
   def __init__(self, llm=None):
       self.llm = llm or LocalLLM()
       self.historical past = ()


   def _extract_json(self, textual content):
       strive:
           return json.hundreds(textual content)
       besides:
           begin, finish = textual content.discover('{'), textual content.rfind('}')+1
           if begin >= 0 and finish > begin:
               strive:
                   return json.hundreds(textual content(begin:finish))
               besides:
                   cross
       return None

Wir definieren die Systemeingabeaufforderungen für die Rollen Planner, Executor und Tester unseres DataOps-Agenten. Anschließend initialisieren wir die DataOpsAgent-Klasse mit Hilfsmethoden und einem JSON-Extraktionsdienstprogramm, um strukturierte Antworten zu analysieren. Wir bereiten die Grundlage für die Argumentations- und Ausführungspipeline des Agenten. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

 def plan(self, process, data_info):
       print("n" + "="*60)
       print("PHASE 1: PLANNING")
       print("="*60)
       immediate = f"Activity: {process}nnData Info:n{data_info}nnCreate an execution plan as JSON with steps, expected_output, and validation_criteria."
       plan_text = self.llm.generate(immediate, PLANNER_PROMPT, temperature=0.2)
       self.historical past.append(("PLANNER", plan_text))
       plan = self._extract_json(plan_text) or {"steps":(process),"expected_output":"Processed knowledge","validation_criteria":("Consequence generated","No errors")}
       print(f"n Plan Created:")
       print(f"  Steps: {len(plan.get('steps', ()))}")
       for i, step in enumerate(plan.get('steps', ()), 1):
           print(f"    {i}. {step}")
       print(f"  Anticipated: {plan.get('expected_output', 'N/A')}")
       return plan


   def execute(self, plan, data_context):
       print("n" + "="*60)
       print("PHASE 2: EXECUTION")
       print("="*60)
       steps_text="n".be a part of(f"{i}. {s}" for i, s in enumerate(plan.get('steps', ()), 1))
       immediate = f"Activity Steps:n{steps_text}nnData out there: DataFrame 'df'n{data_context}nnWrite Python code to execute these steps. Retailer remaining end in 'outcome' variable."
       code = self.llm.generate(immediate, EXECUTOR_PROMPT, temperature=0.1)
       self.historical past.append(("EXECUTOR", code))
       if "```python" in code: code = code.break up("```python")(1).break up("```")(0)
       elif "```" in code: code = code.break up("```")(1).break up("```")(0)
       traces = ()
       for line in code.break up('n'):
           s = line.strip()
           if s and (not s.startswith('#') or 'import' in s):
               traces.append(line)
       code="n".be a part of(traces).strip()
       print(f"n Generated Code:n" + "-"*60)
       for i, line in enumerate(code.break up('n')(:15),1):
           print(f"{i:2}. {line}")
       if len(code.break up('n'))>15: print(f"    ... ({len(code.break up('n'))-15} extra traces)")
       print("-"*60)
       return code

Wir implementieren die Planungs- und Ausführungsphasen des Agenten. Wir lassen den Planer detaillierte Aufgabenschritte und Validierungskriterien erstellen, und dann generiert der Ausführende den entsprechenden Python-Code basierend auf Pandas, um die Aufgabe auszuführen. Wir visualisieren, wie der Agent autonom von der Argumentation zur Generierung umsetzbaren Codes übergeht. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def check(self, plan, outcome, execution_error=None):
       print("n" + "="*60)
       print("PHASE 3: TESTING & VERIFICATION")
       print("="*60)
       result_desc = f"EXECUTION ERROR: {execution_error}" if execution_error else f"Consequence kind: {kind(outcome).__name__}n"
       if not execution_error:
           if isinstance(outcome, pd.DataFrame):
               result_desc += f"Form: {outcome.form}nColumns: {checklist(outcome.columns)}nSample:n{outcome.head(3).to_string()}"
           elif isinstance(outcome, (int,float,str)):
               result_desc += f"Worth: {outcome}"
           else:
               result_desc += f"Worth: {str(outcome)(:200)}"
       criteria_text="n".be a part of(f"- {c}" for c in plan.get('validation_criteria', ()))
       immediate = f"Validation Standards:n{criteria_text}nnExpected: {plan.get('expected_output', 'N/A')}nnActual Consequence:n{result_desc}nnEvaluate if outcome meets standards. Return JSON with handed (true/false), points, and suggestions."
       test_result = self.llm.generate(immediate, TESTER_PROMPT, temperature=0.2)
       self.historical past.append(("TESTER", test_result))
       test_json = self._extract_json(test_result) or {"handed":execution_error is None,"points":("Couldn't parse check outcome"),"suggestions":("Overview manually")}
       print(f"n✓ Check Outcomes:n  Standing: {' PASSED' if test_json.get('handed') else ' FAILED'}")
       if test_json.get('points'):
           print("  Points:")
           for problem in test_json('points')(:3):
               print(f"    • {problem}")
       if test_json.get('suggestions'):
           print("  Suggestions:")
           for rec in test_json('suggestions')(:3):
               print(f"    • {rec}")
       return test_json


   def run(self, process, df=None, data_info=None):
       print("n SELF-VERIFYING DATA-OPS AGENT (Native HF Mannequin)")
       print(f"Activity: {process}n")
       if data_info is None and df is just not None:
           data_info = f"Form: {df.form}nColumns: {checklist(df.columns)}nSample:n{df.head(2).to_string()}"
       plan = self.plan(process, data_info)
       code = self.execute(plan, data_info)
       outcome, error = None, None
       strive:
           local_vars = {'pd': pd, 'np': np, 'df': df}
           exec(code, local_vars)
           outcome = local_vars.get('outcome')
       besides Exception as e:
           error = str(e)
           print(f"n  Execution Error: {error}")
       test_result = self.check(plan, outcome, error)
       return {'plan': plan,'code': code,'outcome': outcome,'check': test_result,'historical past': self.historical past}

Wir konzentrieren uns auf die Check- und Verifizierungsphase unseres Workflows. Wir lassen den Agenten seine eigene Ausgabe anhand vordefinierter Validierungskriterien bewerten und das Ergebnis als strukturiertes JSON zusammenfassen. Anschließend integrieren wir alle drei Phasen, Planung, Ausführung und Check, in einer einzigen selbstverifizierenden Pipeline, die eine vollständige Automatisierung gewährleistet. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def demo_basic(agent):
   print("n" + "#"*60)
   print("# DEMO 1: Gross sales Information Aggregation")
   print("#"*60)
   df = pd.DataFrame({'product':('A','B','A','C','B','A','C'),
                      'gross sales':(100,150,200,80,130,90,110),
                      'area':('North','South','North','East','South','West','East')})
   process = "Calculate whole gross sales by product"
   output = agent.run(process, df)
   if output('outcome') is just not None:
       print(f"n Closing Consequence:n{output('outcome')}")
   return output


def demo_advanced(agent):
   print("n" + "#"*60)
   print("# DEMO 2: Buyer Age Evaluation")
   print("#"*60)
   df = pd.DataFrame({'customer_id':vary(1,11),
                      'age':(25,34,45,23,56,38,29,41,52,31),
                      'purchases':(5,12,8,3,15,7,9,11,6,10),
                      'spend':(500,1200,800,300,1500,700,900,1100,600,1000)})
   process = "Calculate common spend by age group: younger (underneath 35) and mature (35+)"
   output = agent.run(process, df)
   if output('outcome') is just not None:
       print(f"n Closing Consequence:n{output('outcome')}")
   return output


if __name__ == "__main__":
   print(" Initializing Native LLM...")
   print("Utilizing CPU mode for optimum compatibilityn")
   strive:
       llm = LocalLLM(use_8bit=False)
       agent = DataOpsAgent(llm)
       demo_basic(agent)
       print("nn")
       demo_advanced(agent)
       print("n" + "="*60)
       print(" Tutorial Full!")
       print("="*60)
       print("nKey Options:")
       print("  • 100% Native - No API calls required")
       print("  • Makes use of Phi-2 from Microsoft (2.7B params)")
       print("  • Self-verifying 3-phase workflow")
       print("  • Runs on free Google Colab CPU/GPU")
   besides Exception as e:
       print(f"n Error: {e}")
       print("Troubleshooting:n1. pip set up -q transformers speed up scipyn2. Restart runtimen3. Attempt a distinct mannequin")

Wir haben zwei Demobeispiele erstellt, um die Fähigkeiten des Agenten anhand einfacher Verkaufs- und Kundendatensätze zu testen. Wir initialisieren das Modell, führen den Information-Ops-Workflow aus und beobachten den gesamten Zyklus von der Planung bis zur Validierung. Wir schließen das Tutorial mit einer Zusammenfassung der wichtigsten Vorteile ab und ermutigen zu weiteren Experimenten mit lokalen Modellen.

Zusammenfassend haben wir ein vollständig autonomes und selbstverifizierendes DataOps-System erstellt, das auf einem lokalen Hugging Face-Modell basiert. Wir erleben, wie jede Part – Planung, Ausführung und Exams – nahtlos zusammenwirkt, um zuverlässige Ergebnisse zu erzielen, ohne auf Cloud-APIs angewiesen zu sein. Dieser Workflow unterstreicht die Stärke lokaler LLMs wie Phi-2 für eine leichte Automatisierung und inspiriert uns, diese Architektur in Zukunft für fortschrittlichere Datenpipelines, Validierungsframeworks und Multi-Agenten-Datensysteme zu erweitern.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser Publication. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

https://www.youtube.com/watch?v=2gbaifv4sqy

Das Information Science -Interviewprozess kann einschüchternd sein, insbesondere für Neuankömmlinge des Feldes. Laut unserer jüngsten Umfrage, die während eines Webinars durchgeführt wurde, fühlen sich mehr als 75% der angehenden Datenfachleute für den Datenwissenschaftterinterviewprozess nicht vorbereitet oder völlig neu. Wenn Sie unter ihnen sind, sind Sie nicht allein – und dieser Leitfaden ist für Sie.

Um diesen wichtigen Karriereschritt zu entmystifizieren, teilte Kishawna Peck, Gründerin und CEO von WOMXN in Information Science, kürzlich ihre Experteninterviewstrategien während unseres Masterclass -Webinars von Information Profession. Kishawna bringt mehr als 10 Jahre Erfahrung in Bezug auf gemeinnützige Organisationen, Fintech und Werbung in Bezug auf gemeinnützige Organisationen, Fintech und Werbung, und bringt wertvolle Einblicke in das, was Personalmanager wirklich in Datenkandidaten suchen.

Dieser Leitfaden destilliert ihre bewährten Strategien, mit denen Sie sich mit Zuversicht Ihrem nächsten Information Science -Interview nähern können.

Verständnis der Perspektive des Einstellungsmanagers

Bevor Sie Ihre Interviewantworten perfektionieren, Verständnis Was Einstellungsmanager suchen nach einem wertvollen Kontext für Ihre Vorbereitung. Wie Kishawna erklärt, bewerten Personalmanager Kandidaten in drei Hauptdimensionen:

1. Technische und nichttechnische Passform für die Rolle
2. Insgesamt slot in die Unternehmenskultur
3. Wachstumspotenzial und Fortschritt

Unter Berücksichtigung dieser Bewertungskriterien können Sie Ihre Vorbereitung an jeden Bereich anpassen.

1. Technische und nichttechnische Fähigkeiten

Um Ihre technische Kompetenz zu demonstrieren, empfiehlt Kishawna:

• Untersuchung der spezifischen Werkzeuge und Technologien des Unternehmens (über Glassdoor, Unternehmensblogs, Tech -Artikel)
• Praktizieren von Codierungsproblemen und Überprüfung relevanter Frameworks
• Polieren Sie Ihre Fähigkeit, Datenkonzepte klar und präzise zu erklären

„Manchmal erhalten Sie die einfachsten Fragen zu Statistiken, beispielsweise in einem Information Science -Interview, da sie versuchen, sicherzustellen, dass Sie die Grundlagen kennen“, bemerkt Kishawna. „Es ist sehr wichtig, sicherzustellen, dass Sie auf der technischen Seite bereit sind.“

2. Insgesamt match für die Rolle

Über technische Fähigkeiten hinaus möchten Einstellungsmanager sehen, dass Sie sich mit der Unternehmenskultur und den Werten der Unternehmenswerte übereinstimmen:

• Erforschen Sie die Mission und die Werte des Unternehmens (Unternehmenswebsite, aktuelle Nachrichtenartikel)
• Verstehen Sie ihre Marktposition (wachsen sie, kontraktieren sich, drehbar?)
• Bereiten Sie Geschichten vor, die Ihre Erfahrung in Bezug auf ihre Werte zeigen

3. Wachstumspotenzial

Einstellungsmanager möchten visualisieren, wie Sie sich innerhalb der Organisation entwickeln können:

• Markieren Sie Beispiele für das Wachstum und die Anpassungsfähigkeit in der Vergangenheit
• Stellen Sie aufschlussreiche Fragen zu zukünftigen Projekten
• Betonen Sie Ihr Engagement für kontinuierliches Lernen

Wie Kishawna rät:

Wenn Sie 100% der Kriterien in der Stellenbeschreibung erfüllen, sollten Sie sich nicht bewerben. Sie sind überqualifiziert. Sie möchten Raum für Wachstum haben. Aus Sicht des Einstellungsmanagers möchte ich in der Lage sein, zu visualisieren, wie Sie innerhalb dieser Rolle wachsen und innerhalb des Unternehmens wachsen können.

Beherrschen Sie verschiedene Arten von Interviewfragen

Eine unserer Webinar-Umfragen ergab, dass technische Fragen (45%) und Fallszenario-basierte Fragen (24%) die größte Besorgnis für Kandidaten verursachen. Lassen Sie uns die wichtigsten Fragetypen aufschlüsseln und wie Sie sich jeweils effektiv nähern.

Technische und fallbasierte Fragen

Für diese Fragen empfiehlt Kishawna die Verwendung der CODE Verfahren:

C – Klären Sie bei Bedarf die Frage

O – Überrissen Sie Ihren Ansatz, bevor Sie eintauchen

D – Demonstrieren Sie Ihre Lösung (schreiben Sie Code oder erläutern Sie Ihren Prozess).

E – Bewerten Sie Ihre Lösung, diskutieren Sie Kantenfälle und mögliche Verbesserungen

Dieser strukturierte Ansatz zeigt Ihren analytischen Denkprozess und Ihre Fähigkeiten zur Problemlösung.

So könnte dies in der Praxis aussehen:

Arten von technischen Bewertungen

Kishana hob drei gängige technische Bewertungsformate hervor:

• Bewertungen zum Mitnehmen: Zu Ihrer eigenen Zeit abgeschlossen, normalerweise mit einem Tag oder mehr zu vervollständigen
• Paarprogrammierung: Zusammenarbeit mit einem Teammitglied, um ein Drawback gemeinsam zu lösen
• Dwell -Codierung: Lösen von technischen Problemen in Echtzeit während des Interviews

Kishawna rät:

Ein Tipp besteht darin, vorher nach dem Bewertungsformat zu fragen. Auf diese Weise machen Sie sich Wochen im Voraus keine Sorgen, wie Sie sich vorbereiten können.

Verhaltensfragen

Obwohl diese Fragen weniger einschüchternd erscheinen, sind sie entscheidend für die Bewertung Ihrer Gentle Abilities und der vergangenen Leistung. Der STERN Die Methode hilft, Ihre Antworten effektiv zu strukturieren:

S – State of affairs: Szene die Szene

T – Aufgabe: Erläutern Sie Ihre Rolle und Verantwortlichkeiten

A – Aktion: Beschreiben Sie, was Sie getan haben

R – Ergebnis: Teilen Sie das Ergebnis und seine Auswirkungen mit

Zum Beispiel:

Frage: „Erzähl mir von einer Zeit, als du einer schwierigen Frist gegenübersteht. Wie bist du damit umgegangen?“

Antwort: „Bei meinem früheren Unternehmen hatte ich eine zweiwöchige Frist, um ein Vorhersagemodell für unser Produktteam (State of affairs) zu entwickeln. Ich warfare für die Bereitstellung eines genauen Modells verantwortlich, das das Engagement der Benutzer (Aufgabe) verbessert. (Ergebnis).“

Kulturgepasste Fragen

Diese Fragen ermitteln, ob Sie in der Umgebung des Unternehmens gedeihen. Kishawna schlägt vor, die zu verwenden REIHE Verfahren:

R – Relevante Erfahrung

O – Wachstumschancen

W – Möglichkeiten zum Beitrag

Zum Beispiel:

Frage: „Wie können Sie mit Tendencies in der Datenwissenschaft Schritt halten und was motiviert Sie, in einem so schnell verändernden Feld auf dem neuesten Stand zu bleiben?“

Antwort: „Ich engagiere mich regelmäßig mit Information Science Communities, nehme On-line-Kurse und nehme an Konferenzen teil, um auf dem neuesten Stand zu bleiben (relevante Erfahrung). Ich freue mich besonders über die Weiterentwicklung meiner Fähigkeiten in Bezug auf die Ethik, die mit dem Fokus Ihres Unternehmens auf verantwortungsbewusste Innovationen übereinstimmen (Möglichkeiten für das Wachstum). Ich freue mich darauf, Erkenntnisse und Instruments mit dem Workforce zu tauschen, um vorwärts zu denken und das Wachstum zu unterstützen.“

Nachdenkliche Fragen stellen

Einer der am meisten übersehenen Aspekte der Vorbereitung der Interviews ist die Entwicklung sinnvoller Fragen, um den Interviewer zu stellen. Wie Kishawna betont: „Wenn ich ein Interview habe und es keine Fragen vom Befragten gibt, werde ich misstrauisch. Warum haben Sie keine Fragen?“

Das Stellen aufschlussreicher Fragen dient zwei Zwecken: Es zeigt Ihr echtes Interesse an der Rolle und hilft Ihnen, zu bewerten, ob das Unternehmen intestine zu Ihren Karrierezielen passt.

Hier sind einige kraftvolle Fragen, die Kishawna empfiehlt:

• „Welchen Rat würden Sie jemandem geben, der in den ersten 90 Tagen einen Einfluss auf diese Rolle haben möchte?“
• „Wie stellen Sie sich diese Rolle vor, die das Workforce unterstützt und was sind die wichtigsten Ziele für das nächste Jahr?“
• „Was genießen Sie es, dieses Workforce zu führen, und wie stellen Sie sich diese Rolle vor, die zu dieser Umgebung beiträgt?“
• „Wie arbeitet das Information -Workforce mit anderen Abteilungen zusammen?“
• „Welche Rolle spielt das Datenteam bei der Entscheidungsfindung im gesamten Unternehmen?“

Kishawnas Lieblingsabschlussfrage: „Hast du irgendwelche Zögern über mein Profil und meine Fähigkeit, diese Rolle hervorzuheben?“ Diese Frage bietet die Möglichkeit, alle Bedenken direkt vor dem Verlassen des Interviews auszusprechen.

„Wenn Sie ein“ Nein „bekommen, dass sie kein Zögern über Ihr Profil haben, ist das wirklich intestine und es bedeutet, dass Sie wahrscheinlich die Rolle bekommen“, bemerkt sie.

Beantwortung der Gehaltsfrage

Viele Kandidaten fühlen sich unwohl über die Entschädigung diskutieren, aber wie Kishawna betont: „Sie sind nicht freiwillig – Sie suchen nach einem Job, um Geld zu verdienen, um auf sich und Ihre Familie aufzupassen.“

Hier sind ihre Empfehlungen für die Behandlung von Gehaltsdiskussionen:

1. Forschen Sie Ihre Recherchen: Verwenden Sie Ressourcen wie Glassdoor, um typische Bereiche für ähnliche Rollen bei vergleichbaren Unternehmen zu verstehen.
2. Fragen Sie früh nach dem Gehaltsbereich: Versuchen Sie, während des ersten Screening -Anrufs über die Reichweite des Unternehmens zu erfahren, bevor sie nach Ihren Erwartungen fragen.

3. Kennen Sie Ihre Zahlen: Entscheiden Sie sich im Voraus für Ihre Ziel- und Walkaway -Zahlen.

   Kishawna rät:

   Normalerweise für Ihr Ziel, so dass Sie einen Bereich auswählen, und ich würde sagen, was auch immer Ihr Hintern ist, würde ich 10 bis 15% hinzufügen. Wenn Ihr Hintern 50.000 wäre und Sie wissen, dass Sie damit sehr zufrieden wären, würde ich 55 bis 70.000 sagen.

4. Betrachten Sie Verhandlungen über das Gehalt hinaus: Wenn das angebotene Gehalt unter Ihren Erwartungen liegt, sollten Sie die Verhandlungen in Betracht ziehen:
   • Urlaubszeit (oft am einfachsten zu verhandeln)
   • Fernarbeit Flexibilität
   • Leistungen Startdatum
   • Funds für berufliche Entwicklung
   • Transportkosten
5. Stellen Sie sich fest auf Ihre Nicht-Negotablen: Wissen Sie, was Ihnen wirklich wichtig ist:
   • Karrierewachstumschancen
   • Leistungspaket
   • Work-Life Steadiness
   • Teamkultur

Kishawna sagt:

Sie möchten keinen Ressentiment haben, wenn Sie herausgefunden haben, dass andere Leute verhandelt und Sie entschieden haben, dass Sie nicht wollten, weil Sie versuchten, nett zu sein. Es ist Geschäft. Es ist ein Austausch. Stellen Sie additionally sicher, dass Sie verhandeln.

Put up-Interview-Schritte

Nach dem Abschluss des Interviews empfiehlt Kishawna diese Observe-up-Aktionen:

1. Über Passform nachdenken: Bewerten Sie, ob die Rolle und das Workforce Ihren Werten und Karrierezielen übereinstimmen. „Es ist möglich, zu einem Interview zu gehen und zu erkennen, dass Sie diese Rolle nicht wollen. Es passt nicht intestine zu Ihnen“, bemerkt Kishawna.
2. Senden Sie eine personalisierte Dankes-E-Mail: Verweisen Sie auf bestimmte Themen aus Ihrem Gespräch. „Wenn ich es wie ein grundlegendes Dosen hat – wir öffnen es, aber ich bin es nicht ernst. Aber wenn es eine ist, über die wir auf Dinge verweisen, über die wir gesprochen haben, dann habe ich es normalerweise durchgelesen“, sagt Kishawna.
3. Angemessen nachverfolgen: Warten Sie bis nach der Zeitleiste, die sie zur Verfügung gestellt haben, bevor Sie Ihren Bewerbungsstatus überprüfen.
4. Überprüfen Sie das Angebot sorgfältig: Lesen Sie alle Begriffe gründlich durch, bevor Sie akzeptieren oder verhandeln.

Letzte Vorbereitungstipps

Wenn sich Ihr Interview nähert, bietet Kishawna diese letzten Ratschläge an:

• Überprüfen Sie Ihre wichtigsten Fähigkeiten und Geschichten: Stellen Sie sicher, dass sie den Rollenanforderungen übereinstimmen
• Verfeinern Sie Ihre Fragen: Bereiten Sie nachdenkliche Fragen vor, die Ihr Interesse zeigen
• Holen Sie sich ausreichende Pause: „Es ist nicht sinnvoll, ein Interview zu betonen. Sie möchten als Ihr Bestes sein. Sie möchten ruhig sein. Sie möchten zuversichtlich sein.“
• Planen Sie etwas Entspannendes für danach: Planen Sie nach dem Interview etwas Erfreude, um Stress abzubauen

Übung mit KI -Interviewsimulation

Um Sie effektiver vorzubereiten, hat Kishawna eine erweiterte LLM -Interview -Eingabeaufforderung entwickelt, mit der Sie Folgendes haben:

• Erstellen Sie personalisierte Praxisfragen basierend auf Ihrem Lebenslauf und der Zielbeschreibung
• Führen Sie Scheininterviews mit Stimme oder Textual content durch
• Erhalten Sie Suggestions zur Verwendung der Methoden Code, Stern und Zeilen

Sie können hier auf diese wertvolle Ressource zugreifen: Verbesserte LLM -Interviewer -Eingabeaufforderung

Dieses interaktive Software kann dazu beitragen, Ihr Selbstvertrauen aufzubauen, insbesondere wenn Sie niemanden zur Verfügung haben, um Scheininterviews mit Ihnen durchzuführen.

Letzte Gedanken

Das Information Science -Interviewprozess magazine entmutigend erscheinen, aber mit ordnungsgemäßer Vorbereitung und der richtigen Einstellung können Sie Ihre Fähigkeiten effektiv präsentieren und bewerten, ob die Rolle wirklich zu Ihren Karrierezielen passt. Erinnern Sie sich an Kishawnas Schlüsselrat:

Sie sind in die Interviewphase gekommen, additionally müssen Sie etwas richtig machen. Additionally bleib ruhig und selbstbewusst.

Basierend auf meiner Erfahrung mit range-set-blazeein Datenstrukturprojekt, hier sind die von mir empfohlenen Entscheidungen, einzeln beschrieben. Um Wischiwaschi zu vermeiden, formuliere ich sie als Regeln.

Im Jahr 2019 warfare Docker-Mitschöpfer Solomon Hykes getwittert:

Wenn es WASM+WASI im Jahr 2008 gegeben hätte, hätten wir Docker nicht erstellen müssen. So wichtig ist es. Webassembly auf dem Server ist die Zukunft der Datenverarbeitung. Eine standardisierte Systemschnittstelle warfare das fehlende Bindeglied. Hoffen wir, dass WASI dieser Aufgabe gewachsen ist.

Wenn Sie heute Technologienachrichten verfolgen, werden Sie optimistische Schlagzeilen wie diese sehen:

Wenn WASM WASI wirklich bereit und nützlich wäre, würde es bereits jeder nutzen. Die Tatsache, dass wir diese Schlagzeilen immer wieder sehen, deutet darauf hin, dass es noch nicht fertig ist. Mit anderen Worten: Sie müssten nicht ständig darauf bestehen, dass WASM WASI bereit ist, wenn es wirklich so wäre.

Ab WASI Preview 1 ist der Stand der Dinge wie folgt: Sie können auf einige Dateioperationen und Umgebungsvariablen zugreifen und haben Zugriff auf die Zeit- und Zufallszahlengenerierung. Es gibt jedoch keine Unterstützung für die Vernetzung.

WASM WASI könnte für bestimmte Webdienste im AWS-Lambda-Stil nützlich sein, aber selbst das ist ungewiss. Denn würden Sie es nicht vorziehen, Ihren Rust-Code nativ zu kompilieren und im Vergleich zu WASM WASI doppelt so schnell und zur Hälfte der Kosten auszuführen?

Vielleicht ist WASM WASI für Plug-Ins und Erweiterungen nützlich. In der Genomik habe ich eine Rust-Erweiterung für Python, die ich für 25 verschiedene Kombinationen kompiliere (5 Versionen von Python auf 5 Betriebssystemzielen). Trotzdem decke ich nicht alle möglichen Betriebssysteme und Chipfamilien ab. Könnte ich diese Betriebssystemziele durch WASM WASI ersetzen? Nein, es wäre zu langsam. Könnte ich WASM WASI als sechstes „Catch-All“-Ziel hinzufügen? Vielleicht, aber wenn ich wirklich Portabilität benötige, muss ich Python bereits unterstützen und sollte einfach Python verwenden.

Wofür ist WASM WASI additionally intestine? Derzeit liegt sein Hauptwert darin, dass er einen Schritt hin zur Ausführung von Code im Browser oder auf eingebetteten Systemen darstellt.

In Regel 1 habe ich nebenbei „Betriebssystemziele“ erwähnt. Schauen wir uns die Rust-Ziele genauer an – wichtige Informationen nicht nur für WASM WASI, sondern auch für die allgemeine Rust-Entwicklung.

Auf meinem Home windows-Rechner kann ich ein Rust-Projekt kompilieren, um es unter Linux oder macOS auszuführen. Ebenso kann ich von einem Linux-Rechner aus ein Rust-Projekt für Home windows oder macOS kompilieren. Hier sind die Befehle, die ich verwende, um das Linux-Ziel zu einem Home windows-Pc hinzuzufügen und zu überprüfen:

rustup goal add x86_64-unknown-linux-gnu
cargo test --target x86_64-unknown-linux-gnu

Nebenbei: Während cargo test Überprüft, ob der Code kompiliert wird. Für die Erstellung einer voll funktionsfähigen ausführbaren Datei sind zusätzliche Instruments erforderlich. Für die Crosskompilierung von Home windows zu Linux (GNU) müssen Sie außerdem den Linux GNU C/C++-Compiler und die entsprechende Toolchain installieren. Das kann schwierig sein. Glücklicherweise ist die erforderliche Toolchain für die WASM-Ziele, die uns wichtig sind, einfach zu installieren.

Um alle von Rust unterstützten Ziele anzuzeigen, verwenden Sie den folgenden Befehl:

rustc --print target-list

Es werden über 200 Ziele aufgelistet, darunter x86_64-unknown-linux-gnu, wasm32-wasip1Und wasm32-unknown-unknown.

Zielnamen bestehen aus bis zu vier Teilen: CPU-Familie, Hersteller, Betriebssystem und Umgebung (z. B. GNU vs. LVMM):

Nachdem wir nun etwas über Ziele verstanden haben, können wir mit der Set up des Ziels fortfahren, das wir für WASM WASI benötigen.

Um unseren Rust-Code auf WASM außerhalb eines Browsers auszuführen, müssen wir ihn gezielt ausführen wasm32-wasip1 (32-Bit-WebAssembly mit WASI-Vorschau 1). Wir werden auch WASMTIME installieren, eine Laufzeit, die es uns ermöglicht, WebAssembly-Module mithilfe von WASI außerhalb des Browsers auszuführen.

rustup goal add wasm32-wasip1
cargo set up wasmtime-cli

Um unser Setup zu testen, erstellen wir eine neue „Hey, WebAssembly!“ Rust-Projekt mit cargo new. Dadurch wird ein neues Rust-Paket initialisiert:

cargo new hello_wasi
cd hello_wasi

Bearbeiten src/principal.rs zu lesen:

fn principal() {
#(cfg(not(target_arch = "wasm32")))
println!("Hey, world!");
#(cfg(target_arch = "wasm32"))
println!("Hey, WebAssembly!");
}

Nebenbei: Wir werden uns das genauer ansehen #(cfg(...)) Attribut, das die bedingte Kompilierung ermöglicht, in Regel 4.

Führen Sie nun das Projekt mit aus cargo runund Sie sollten sehen Hey, world! auf der Konsole gedruckt.

Als nächstes erstellen Sie eine .cargo/config.toml Datei, die angibt, wie Rust das Projekt ausführen und testen soll, wenn es auf WASM WASI abzielt.

(goal.wasm32-wasip1)
runner = "wasmtime run --dir ."

Nebenbei: Dies .cargo/config.toml Die Datei unterscheidet sich von der Hauptdatei Cargo.toml Datei, die die Abhängigkeiten und Metadaten Ihres Projekts definiert.

Wenn Sie nun sagen:

cargo run --target wasm32-wasip1

Das solltest du sehen Hey, WebAssembly!. Glückwunsch! Sie haben gerade erfolgreich Rust-Code in der Container-ähnlichen WASM WASI-Umgebung ausgeführt.

Lassen Sie uns nun der Sache nachgehen #(cfg(...))– ein unverzichtbares Werkzeug zum bedingten Kompilieren von Code in Rust. In Regel 3 sahen wir:

fn principal() {
#(cfg(not(target_arch = "wasm32")))
println!("Hey, world!");
#(cfg(target_arch = "wasm32"))
println!("Hey, WebAssembly!");
}

Der #(cfg(...)) Zeilen weisen den Rust-Compiler an, bestimmte Codeelemente basierend auf bestimmten Bedingungen einzuschließen oder auszuschließen. Ein „Codeelement“ bezieht sich auf eine Codeeinheit wie eine Funktion, Anweisung oder einen Ausdruck.

Mit #(cfg(…)) Zeilen können Sie Ihren Code bedingt kompilieren. Mit anderen Worten: Sie können unterschiedliche Versionen Ihres Codes für unterschiedliche Situationen erstellen. Zum Beispiel beim Kompilieren für die wasm32 Ziel, der Compiler ignoriert das #(cfg(not(target_arch = "wasm32"))) Block und umfasst nur Folgendes:

fn principal() {
println!("Hey, WebAssembly!");
}

Sie geben Bedingungen über Ausdrücke an, z. B. target_arch = "wasm32". Zu den unterstützten Schlüsseln gehören: target_os Und target_arch. Siehe die Rust-Referenz für die vollständige Liste der unterstützten Schlüssel. Sie können Ausdrücke auch mit Cargo-Funktionen erstellen, worüber wir in Regel 6 erfahren.

Sie können Ausdrücke mit den logischen Operatoren kombinieren not, anyUnd all. Die bedingte Kompilierung von Rust verwendet keine traditionelle Kompilierung if...then...else Aussagen. Stattdessen müssen Sie verwenden #(cfg(...)) und seine Negation, um verschiedene Fälle zu behandeln:

#(cfg(not(target_arch = "wasm32")))
...
#(cfg(target_arch = "wasm32"))
...

Um eine ganze Datei bedingt zu kompilieren, platzieren Sie #!(cfg(...)) oben in der Datei. (Beachten Sie das „!“). Dies ist nützlich, wenn eine Datei nur für ein bestimmtes Ziel oder eine bestimmte Konfiguration related ist.

Sie können auch verwenden cfg Ausdrücke in Cargo.toml Abhängigkeiten bedingt einzubeziehen. Dadurch können Sie Abhängigkeiten an verschiedene Ziele anpassen. Hier heißt es zum Beispiel: „Verlassen Sie sich auf Criterion mit Rayon, wenn Sie nicht zielen.“ wasm32“.

(goal.'cfg(not(target_arch = "wasm32"))'.dev-dependencies)
criterion = { model = "0.5.1", options = ("rayon") }

Nebenbei: Weitere Informationen zur Verwendung cfg Ausdrücke in Cargo.tomlsiehe meinen Artikel: Neun Rust Cargo.toml Wats und Wat Nots: Beherrschen Sie die Formatierungsregeln von Cargo.toml und vermeiden Sie Frustration | Auf dem Weg zur Datenwissenschaft (medium.com).

Es ist Zeit zu versuchen zu rennen dein Projekt zu WASM WASI. Erstellen Sie wie in Regel 3 beschrieben eine .cargo/config.toml Datei für Ihr Projekt. Es erklärt Cargo, wie es Ihr Projekt auf WASM WASI ausführen und testen soll.

(goal.wasm32-wasip1)
runner = "wasmtime run --dir ."

Nächste, Ihr Projekt sollte – wie jeder gute Code – bereits Checks enthalten. Mein range-set-blaze Das Projekt umfasst beispielsweise diesen Take a look at:

#(take a look at)
fn insert_255u8() {
let range_set_blaze = RangeSetBlaze::<u8>::from_iter((255));
assert!(range_set_blaze.to_string() == "255..=255");
}

Versuchen wir nun, die Checks Ihres Projekts auf WASM WASI auszuführen. Verwenden Sie den folgenden Befehl:

cargo take a look at --target wasm32-wasip1

Wenn das funktioniert, sind Sie vielleicht fertig – aber es wird wahrscheinlich nicht funktionieren. Wenn ich das anprobiere range-set-blazeerhalte ich diese Fehlermeldung, die sich über die Verwendung von Rayon auf WASM beschwert.

 error: Rayon can't be used when focusing on wasi32. Strive disabling default options.
--> C:Userscarlk.cargoregistrysrcindex.crates.io-6f17d22bba15001fcriterion-0.5.1srclib.rs:31:1
|
31 | compile_error!("Rayon can't be used when focusing on wasi32. Strive disabling default options.");

Um diesen Fehler zu beheben, müssen wir zunächst die Cargo-Funktionen verstehen.

Um Probleme wie den Rayon-Fehler in Regel 5 zu beheben, ist es wichtig zu verstehen, wie die Cargo-Funktionen funktionieren.

In Cargo.tomlein optionales (options) Im Abschnitt können Sie verschiedene Konfigurationen oder Versionen Ihres Projekts definieren, je nachdem, welche Funktionen aktiviert oder deaktiviert sind. Hier ist zum Beispiel ein vereinfachter Teil davon Cargo.toml Datei aus der Kriterien-Benchmarking-Projekt:

(options)
default = ("rayon", "plotters", "cargo_bench_support")
rayon = ("dep:rayon")
plotters = ("dep:plotters")
html_reports = ()
cargo_bench_support = ()
(dependencies)
#...
# Elective dependencies
rayon = { model = "1.3", elective = true }
plotters = { model = "^0.3.1", elective = true, default-features = false, options = (
"svg_backend",
"area_series",
"line_series",
) }

Dies definiert vier Cargo-Funktionen: rayon, plotters, html_reportsUnd cargo_bench_support. Da jede Funktion ein- oder ausgeschlossen werden kann, ergeben diese vier Funktionen 16 mögliche Konfigurationen des Projekts. Beachten Sie auch die spezielle Commonplace-Cargo-Funktion.

Eine Cargo-Funktion kann andere Cargo-Funktionen umfassen. Im Beispiel das Besondere default Die Cargo-Funktion umfasst drei weitere Cargo-Funktionen: rayon, plottersUnd cargo_bench_support.

Eine Cargo-Funktion kann eine Abhängigkeit enthalten. Der rayon Die obige Frachtfunktion umfasst die rayon Kiste als abhängiges Paket.

Darüber hinaus können abhängige Pakete über eigene Cargo-Funktionen verfügen. Zum Beispiel die plotters Die obige Frachtfunktion umfasst die plotters abhängiges Paket mit den folgenden aktivierten Cargo-Funktionen: svg_backend, area_seriesUnd line_series.

Sie können angeben, welche Cargo-Funktionen beim Ausführen aktiviert oder deaktiviert werden sollen cargo test, cargo construct, cargo runoder cargo take a look at. Wenn Sie beispielsweise am Criterion-Projekt arbeiten und nur Folgendes überprüfen möchten html_reports Funktion ohne Standardeinstellungen können Sie Folgendes ausführen:

cargo test --no-default-features --features html_reports

Dieser Befehl weist Cargo an, standardmäßig keine Cargo-Funktionen einzuschließen, sondern diese gezielt zu aktivieren html_reports Cargo-Funktion.

In Ihrem Rust-Code können Sie Codeelemente basierend auf aktivierten Cargo-Funktionen einschließen/ausschließen. Die Syntax verwendet #cfg(…)gemäß Regel 4:

#(cfg(characteristic = "html_reports"))
SOME_CODE_ITEM

Mit diesem Verständnis der Cargo-Funktionen können wir nun versuchen, das Downside zu beheben Rayon Fehler, der beim Ausführen von Checks auf WASM WASI aufgetreten ist.

Als wir versuchten zu laufen cargo take a look at --target wasm32-wasip1Teil der Fehlermeldung lautete: Criterion ... Rayon can't be used when focusing on wasi32. Strive disabling default options. Dies legt nahe, dass wir Criterion deaktivieren sollten rayon Frachtfunktion beim Anvisieren von WASM WASI.

Dazu müssen wir zwei Änderungen in unserem vornehmen Cargo.toml. Zuerst müssen wir das deaktivieren rayon Funktion von Criterion in der (dev-dependencies) Abschnitt. Additionally diese Startkonfiguration:

(dev-dependencies)
criterion = { model = "0.5.1", options = ("html_reports") }

wird dazu, dass wir die Standardfunktionen für Criterion explizit deaktivieren und dann alle Cargo-Funktionen außer aktivieren rayon.

(dev-dependencies)
criterion = { model = "0.5.1", options = (
"html_reports",
"plotters",
"cargo_bench_support"),
default-features = false }

Als nächstes, um sicherzustellen rayon weiterhin für Nicht-WASM-Ziele verwendet wird, fügen wir es mit einer bedingten Abhängigkeit wieder hinzu Cargo.toml wie folgt:

(goal.'cfg(not(target_arch = "wasm32"))'.dev-dependencies)
criterion = { model = "0.5.1", options = ("rayon") }

Wenn Sie auf WASM WASI abzielen, müssen Sie im Allgemeinen möglicherweise Ihre Abhängigkeiten und ihre Cargo-Funktionen ändern, um die Kompatibilität sicherzustellen. Manchmal ist dieser Prozess unkompliziert, aber manchmal kann er eine Herausforderung sein – oder sogar unmöglich, wie wir in Regel 8 besprechen werden.

Nebenbei: Im nächsten Artikel dieser Reihe – über WASM im Browser – werden wir tiefer auf Strategien zur Behebung von Abhängigkeiten eingehen.

Nachdem wir die Checks erneut ausgeführt haben, überwinden wir den vorherigen Fehler, nur um dann auf einen neuen zu stoßen, was ein Fortschritt ist!

#(take a look at)
fn test_demo_i32_len() {
assert_eq!(demo_i32_len(i32::MIN..=i32::MAX), u32::MAX as usize + 1);
^^^^^^^^^^^^^^^^^^^^^ try to compute 
`usize::MAX + 1_usize`, which might overflow
}

Der Compiler beschwert sich darüber u32::MAX as usize + 1 Überläufe. Unter 64-Bit-Home windows läuft der Ausdruck nicht über, weil usize ist das gleiche wie u64 und halten kann u32::MAX as usize + 1. WASM ist jedoch eine 32-Bit-Umgebung usize ist das gleiche wie u32 und der Ausdruck ist eins zu groß.

Die Lösung hier ist ersetzen usize mit u64um sicherzustellen, dass der Ausdruck nicht überläuft. Im Allgemeinen erkennt der Compiler diese Probleme nicht immer, daher ist es wichtig, dass Sie Ihre Verwendung überprüfen usize Und isize. Wenn Sie sich auf die Größe oder den Index einer Rust-Datenstruktur beziehen, usize ist richtig. Wenn Sie es jedoch mit Werten zu tun haben, die die 32-Bit-Grenzen überschreiten, sollten Sie verwenden u64 oder i64.

Nebenbei: In einer 32-Bit-Umgebung ein Rust-Array, Vec, BTreeSetusw. können nur bis zu 2³²−1=4.294.967.295 Elemente enthalten.

Wir haben additionally das Abhängigkeitsproblem behoben und a usize Überlauf. Aber können wir alles reparieren? Leider lautet die Antwort nein.

WASM WASI Preview 1 (die aktuelle Model) unterstützt den Dateizugriff (innerhalb eines angegebenen Verzeichnisses), das Lesen von Umgebungsvariablen und das Arbeiten mit Zeit und Zufallszahlen. Allerdings sind seine Fähigkeiten im Vergleich zu dem, was Sie von einem vollständigen Betriebssystem erwarten würden, begrenzt.

Wenn Ihr Projekt Zugriff auf Netzwerke, asynchrone Aufgaben mit Tokio oder Multithreading mit Rayon erfordert, werden diese Funktionen in Vorschau 1 leider nicht unterstützt.

Glücklicherweise wird erwartet, dass WASM WASI Preview 2 diese Einschränkungen überwindet und mehr Funktionen bietet, einschließlich einer besseren Unterstützung für Netzwerk- und möglicherweise asynchrone Aufgaben.

So bestehen Ihre Checks auf WASM WASI und Ihr Projekt läuft erfolgreich. Bist du fertig? Nicht ganz. Denn wie ich gerne sage:

Wenn es nicht in CI ist, existiert es nicht.

Steady Integration (CI) ist ein System, das Ihre Checks jedes Mal automatisch ausführen kann, wenn Sie Ihren Code aktualisieren, um sicherzustellen, dass Ihr Code weiterhin wie erwartet funktioniert. Durch das Hinzufügen von WASM WASI zu Ihrem CI können Sie garantieren, dass zukünftige Änderungen die Kompatibilität Ihres Projekts mit dem WASM WASI-Ziel nicht beeinträchtigen.

In meinem Fall wird mein Projekt auf GitHub gehostet und ich verwende GitHub Actions als mein CI-System. Hier ist die Konfiguration, die ich hinzugefügt habe .github/workflows/ci.yml um mein Projekt auf WASM WASI zu testen:

test_wasip1:
identify: Take a look at WASI P1
runs-on: ubuntu-latest
steps:
- identify: Checkout
makes use of: actions/checkout@v4
- identify: Arrange Rust
makes use of: dtolnay/rust-toolchain@grasp
with:
toolchain: secure
targets: wasm32-wasip1
- identify: Set up Wasmtime
run: |
curl https://wasmtime.dev/set up.sh -sSf | bash
echo "${HOME}/.wasmtime/bin" >> $GITHUB_PATH
- identify: Run WASI checks
run: cargo take a look at --verbose --target wasm32-wasip1

Durch die Integration von WASM WASI in CI kann ich sicher neuen Code zu meinem Projekt hinzufügen. CI testet automatisch, ob mein gesamter Code auch in Zukunft WASM WASI unterstützt.