Hey Leute, da ich meine Karriere als Softwareentwickler im Fintech-Bereich beginne, gibt es einige Erkenntnisse darüber, wie sich das Codieren hier von meinen College-/Hackathon-Projekten unterscheidet.

Wenn wir an persönlichen Projekten arbeiten, sind das normalerweise kleine Prototypen unserer Gedanken. Aber da wir an großen Projekten arbeiten, abgesehen vom Schreiben von Geschäftslogik / Implementieren von Datenstrukturalgorithmen, gibt es andere Bereiche, in denen unser Code hängen bleibt und es frustrierend werden kann, diese Probleme zu lösen.

Selbst wenn man gut im Codieren und in Algorithmen ist, führt eine Gesamtvorstellung des Systems zu einem reibungsloseren Erlebnis. Einige Praktiken, bei denen man als Erstsemester ein Brainstorming durchführen kann, sind-

Testgetriebene Entwicklung

Dieser Ansatz kann Ihnen helfen, sauberen Code zu schreiben, der heutzutage ein Muss in der Industrie ist. In Szenarien, in denen es einen Kompromiss zwischen O(N) + sauberem Code und/s O(logN) algorithmischem Code gibt, neigen die Leute im Allgemeinen dazu, Code zu akzeptieren, der sauberer und lesbarer ist.

• Als Neulinge neigen wir dazu, unseren Code zu überarbeiten, nachdem wir beispielsweise fehlgeschlagene Testfälle auf Leetcode/CodeChef/IB oder einer anderen Codierungsplattform sehen, aber während der Arbeit an einem Projekt, das Code ändert und während der QA auf Fehler stößt, kann dies zu unordentlichem und unlesbarem Code führen. Ein Ende-zu-Ende-Gespräch mit Projektmanagern im Vorfeld, das Definieren aller Rand-/Testfälle für die Funktion und das Definieren verschiedener Eingaben/Ausgaben der Funktionen, die Sie schreiben werden, kann dabei helfen, ein besseres Verständnis und Fähigkeiten zur teamübergreifenden Zusammenarbeit aufzubauen, Fehler zu reduzieren und Verbesserung Ihrer Lieferzeit.
• Natürlich schreiben wir aufgrund ihrer zusätzlichen Komplexität und strengen Fristen nicht überall in der Branche UTs, aber selbst eine grobe Blaupause auf Papier zu haben, bevor man mit dem Codieren beginnt, führt schließlich zu einem saubereren Code mit wenigen Fehlern.
• Außerdem schützt das Schreiben von UT Ihre Funktion davor, aufgrund anstehender Entwicklungen beschädigt zu werden.

Wenn wir in ein neues Unternehmen eintreten, möchten wir so schnell wie möglich in die Programmierung und Projekte einsteigen, um eine Wirkung zu erzielen, und ignorieren, wie wichtig es ist, einige Zeit damit zu verbringen, sich mit dem Framework vertraut zu machen, das das Unternehmen verwendet, und die Grundlagen aufzufrischen.

Verbringen Sie einen oder zwei Tage damit, ein umfassendes Wissen über das Framework und seine Methoden/Praktiken zur Injektion von Abhängigkeiten zu schaffen. Wir neigen im Allgemeinen nicht dazu, die Reihenfolge zu sehen, während wir Module injizieren, oder die Anzahl der Module, die wir injizieren, und übersehen kleine Details, wodurch es wahrscheinlicher wird, dass wir auf Probleme wie zirkuläre Abhängigkeiten und Diamantprobleme stoßen. Diese können in den ersten Tagen der Arbeit mit dem neuen Framework frustrierend sein.

In Nest.js empfiehlt es sich beispielsweise, Module anstelle von Diensten zu importieren, da Sie die Wahrscheinlichkeit erhöhen, auf Fehler zu stoßen

Nachdem man die Protokolle durchgesehen hat, könnte man zum RootTestModule gehen, nur um herauszufinden, dass alle Dienste dort problemlos importiert werden, und daher verwirrt werden. Dieses Problem der zirkulären Abhängigkeit kann leicht durch die Verwendung von forwardRef() behoben werden , aber wenn Sie sauberen Code üben möchten, versuchen Sie, solche Codierungspraktiken zu vermeiden.

PS – Ich habe beim Schreiben von AWS Lambda einmal einen großen Fehler gemacht. Unerwünschte Injektionen können zu hohen Initialisierungszeiten führen und sich somit zu Serverkosten und -größe summieren. Dieser Artikel von Amazon AWS für Lambdas ist eine sehr gute Lektüre, um zu erfahren, wie Pannen bei der Abhängigkeitsinjektion vermieden werden können, was zu besseren Leistungsoptimierungen führt. Auch wenn es speziell für Lambdas ist, können Sie sich darauf beziehen, um ein Gesamtbild zu erhalten, um die Bedeutung zu verstehen.

Fehlerbehandlung

Nicht zwischengespeicherte Fehler können zu großen Fehlern führen, die auch während der QA schwer zu erkennen sind.

Die Implementierung eines benutzerdefinierten Fehler-Wrappers auf der Controller-Ebene kann sich langfristig als vorteilhaft erweisen. Sie können mehrere verschiedene Wrapper für verschiedene Arten von Fehlern haben, z. B. Validierungsfehler, Serverfehler und Fehler in Netzwerkvorgängen. Möglicherweise benötigen wir HTTPError, für Datenbankvorgänge DBErrors und so weiter.

In JavaScript haben wir eine eingebaute Error-Klasse

Error {
  constructor(message) {
    this.message = message;
    this.name = "Error"; // (different names for different built-in error classes)
    this.stack = <call stack>; // non-standard, but most environments support it
  }
}

export class ServerError extends Error {
    serverMessage: ServerMessages;
    statusCode: number;
    context: Record<string, string>;

    constructor(
        errorCode: ServerMessages,
        message: string,
        statusCode = 500,
        context: Record<string, string> = {},
    ) {
        super(message);
        this.name = ServerError.name;
        this.serverMessage = errorCode;
        this.statusCode = statusCode;
        this.context = context;
    }
}

1. Fangen Sie immer Ihre Fehler.
2. Vermeiden Sie das Auslösen von Fehlern aus dem Teil des Codes, der asynchron arbeitet, nachdem die Anforderung abgeschlossen ist.

Da wir derzeit unsere Systeme skalieren, suchen wir nach verschiedenen Plattformen/Tools, um unser System zu überwachen, und ich helfe dabei, dass ich mit Sicherheit sagen kann, dass dies eine ganz andere Domäne ist, die man erkunden kann. Die Möglichkeit, APM- oder Infra-Überwachungs-Dashboards und -Warnungen einzurichten, hat mir geholfen, die Architektur besser zu verstehen.

P S —Ich gebe hier keine Details an, da ein paar interessante Artikel über meine Reise in diesem Bereich kommen, bleiben Sie dran!!

Datenbank

Nicht nur das Schreiben von Anfragen und Grundkenntnissen über DBMS ( relational und nicht-relational ), sondern auch das Kennen von Best Practices ist ein Muss. Einige Punkte, auf die Sie beim Schreiben von Code achten sollten, könnten sein:

• Befolgen Sie die Sicherheitspraktiken – Wenn Sie PII-Daten mit einer Verschlüsselung auf Anwendungsebene haben, ist dies eine gute Idee. Wenn nicht, versuchen Sie zu vermeiden, vertrauliche Daten offenen Endpunkten zugänglich zu machen. Die Befolgung der 3-Schichten-Architektur und die immer Implementierung einer DAO-/Datenbankschicht tragen zur Flexibilität in Fällen bei, in denen Sie wechseln oder mehrere DBs verwenden möchten.
• Überwachung der Abfrageleistung – Schreiben Sie immer indizierte Abfragen Das Schreiben von Abfragen auf nicht indizierte Felder ist ein großes NEIN, wenn es um die Leistungsanalyse und -überwachung geht.
• Grundlegende Einblicke in potenzielle Top-Layer-Anforderungen wie eine In-Memory-Datenbank . dh Redis.

Einige Fragen, die Sie Ihren erfahrenen Entwicklern stellen sollten –

Wie hosten wir unsere Dienste für Kunden?

Was sind alle Code-Pipelines, die Sie haben, und welche Bereitstellungspraktiken verwenden wir?

Warum verwenden wir diese?

Was sind andere verfügbare Alternativen?

Generischen Code schreiben

Versuchen Sie, Ihren Code so allgemein wie möglich zu schreiben. Als einfaches Beispiel möchten Sie Code schreiben, um die Hamming-Distanz zwischen zwei Zeichenfolgen zu ermitteln.

export function hammingDistanceBetweenTwoStrings(
    str1: string,
    str2: string,
    comparator: (arg0: string, arg1: string) => boolean,
): number {
    const minLengthAmongTwo =
        str1.length < str2.length ? str1.length : str2.length;

    let diffCharacters = 0;
    for (let i = 0; i < minLengthAmongTwo; i++) {
        const isDifferent = str1.charAt(i).localeCompare(str2.charAt(i)) !== 0;
        if (isDifferent) diffCharacters++;
    }

    return (
        diffCharacters +
        (str1.length - minLengthAmongTwo) +
        (str2.length - minLengthAmongTwo)
    );
}

Aber was, wenn wir es generischer schreiben, indem wir auch hier eine Komparatorfunktion übergeben? Ein einfacher Anwendungsfall kann sein, wenn jemand in Zukunft die Hamming-Distanz mit einer Zeichenfolge ohne Berücksichtigung der Groß-/Kleinschreibung finden möchte.

export function hammingDistanceBetweenTwoStrings(
    str1: string,
    str2: string,
    comparator: (arg0: string, arg1: string) => boolean,
): number {
    const minLengthAmongTwo =
        str1.length < str2.length ? str1.length: str2.length;

    let diffCharacters = 0;
    for (let i = 0; i < minLengthAmongTwo; i++) {
        const isDifferent = comparator(str1.charAt(i), str2.charAt(i));
        if (isDifferent) diffCharacters++;
    }

    return (
        diffCharacters +
        (str1.length - minLengthAmongTwo) +
        (str2.length - minLengthAmongTwo)
    );
}

Ich hoffe, dieser Artikel wird Ihnen helfen, besser zu programmieren, Ihre Fristen einzuhalten und in Ihrem Arbeitsbereich zu töten.

Es gibt noch viel mehr zu wissen, aber das habe ich im vergangenen Jahr entdeckt. Da ich jeden dieser Abschnitte ein wenig untersucht habe, werde ich versuchen, mehr über jedes dieser detaillierten Frameworks/Tools, die wir verwenden, und ihre Vor- und Nachteile zu schreiben. Also bleibt dran Leute.