Forem: Manon

From TypeScript to Rust: Navigating Memory Safety Challenges

Manon — Tue, 21 Jan 2025 04:34:08 +0000

I’m setting out on an exciting new challenge: learning Rust. Why? It’s the most loved programming language, there’s got to be a reason! Plus, I’ve designed a curriculum to help people level up their backend skills to land and work on more meaningful, impactful projects. I’m the first test subject. You can have a look and level up here.

Learning a new programming language isn’t magic.

It’s all about practice and tackling plenty of programming challenges 😊

For example, Leetcode is a solid place to start. Exercise two: Linked List. Even with five years as a developer, I had to refresh my memory. Working as a TypeScript/React/Node.js full-stack developer at startups, you don’t often encounter structures like linked lists.

Simply said, a linked list is a group of nodes where one node points to the next.

I often find it easier to think in analogy. So here's one: a linked list is like a hiking trail with markers in the mountains. Each trail marker (node) points to the next one. You can only move forward step by step, and can't take shortcuts! If you want to reach a specific marker, you have to follow the trail from the start. This makes it simple to add or remove markers (nodes) without messing up the entire trail.

Sometimes you need a structure that’s adaptable, like a trail that can grow or shrink without a complete redesign. Linked lists, for example, are great for apps that manage dynamic tasks, like your daily to-dos. When you add or complete a task, the list adjusts seamlessly, just like updating a trail (if this is a thing at all).

Implementing a Linked List in Rust, it turns out, is a tough one.

I found it harder in Rust compared to, let's say, Typescript, because of its strict ownership and borrowing rules, which are there to ensure memory safety. Each node needs to point to the next, and Rust's borrow checker ensures no mutable reference is active while others exist. In simpler terms, Rust needs to know exactly how much memory to allocate, and where. As a beginner with Rust, wrapping my head around these concepts has been fun.

TypeScript, on the other hand, makes this easier. It’s garbage-collected, so memory management is automatic. You can create nodes as objects and connect them without worrying about ownership, borrowing, or memory allocation. But that simplicity comes with trade-offs (of course): Rust’s strictness leads to better performance and safer code, even if it makes something as "basic" as a linked list harder.

How do we implement a linked list in Rust?

My understanding is that it has to be with dynamic memory allocation. Rust can do this with the <Box> smart pointer, which allocates memory to the heap at runtime instead of the stack. However, this approach introduces challenges, because heap memory isn’t automatically freed, which makes it less safe and contradicts Rust’s core principles.

I’m excited to dig deeper into these safeties issues, if the <Box> container is really the answer, and make a Linked List in Rust!

What about you? How would you approach building a linked list in Rust?

Want to be a better full-stack developer? Know the web and HTTP principles

Manon — Thu, 09 Jan 2025 21:03:07 +0000

Why Build a HTTP server from Scratch?
First, the basics. What Is an HTTP Server?
- TCP vs. UDP
Key features of my HTTP Server (Typescript + Nodejs)
What I Learned
- Learning 1: Sockets!
- Learning 2: Routing Isn’t That Simple
- Learning 3: Always Try to Break Your Software
What’s Next?
Why It Matters - Meta Learnings

Why Build a HTTP server from Scratch?

These days, you can spin up a fully functional server in minutes with the help of modern tools.

So why would anyone bother building an HTTP server from scratch using Nodejs and Typescript?

For me, it's an experiment I am running for the next three months: mastering building blocks fundamentals and re training myself on doing deep work.

There is also a simple truth about working in tech: if I am serious about thriving as a full-stack engineer, I surely need to own the basics, and not just know how to work with abstractions and frameworks that do pretty much everything for you.

Beyond the technical challenge, there’s the simple satisfaction of building something fun and tangible. There’s unparalleled satisfaction in crafting a tool that serves a real purpose, like delivering a web page that serves an HTML page with images and text, using only the basics.

It’s a powerful way to deepen your technical skills in a meaningful way while working on something enjoyable.

First, the basics. What Is an HTTP Server?

At its core, an HTTP server is a program that listens for incoming HTTP requests from clients (like a browser or API consumer), processes those requests, and sends back responses. It uses the TCP (Transmission Control Protocol) to establish a reliable connection, ensuring that data packets arrive in order and intact.

TCP vs. UDP

I do mountaineering and one analogy came to me to differentiate TCP and UDP protocols.

TCP: Think of climbers on a glacier roped together. Everyone reaches the summit securely and in order. That’s TCP: ensuring that data (climbers) arrive in order and intact.
UDP: UDP are like alpinists climbing individually without ropes. It’s usually faster, but there’s no guarantee everyone gets there. Fast, but less reliable.

Key features of my HTTP Server (Typescript + Nodejs)

Handles GET and POST Requests: Responds with a simple “Hello, World!” for basic requests.
Supports for HTTP/1.1 Protocol: Implements the essentials of this widely-used protocol.
Serves Static Files: Fetches and delivers image files stored in the server’s public/images/ directory.
Routing: Implements basic routing using if-else statements to handle different endpoints like /api or /.
Error Handling: Ensures proper responses for malformed requests, like returning 400 Bad Request for parsing errors.

What I Learned

Learning 1: Sockets!

Sockets are how servers and clients talk to each other. Before this project, I knew about sockets the way most of us know about cars: we press the gas pedal, and the car moves. Magic! Now, I’ve seen how there is nothing magical about it, especially when I wrote the createDataHandler function:

const createDataHandler = (
  socket: net.Socket,
  handleRequest: (rawRequest: string) => {
    statusCode: number;
    statusMessage: string;
    headers: Record<string, string>;
    body: string | Buffer;
  },
): ((chunk: Buffer) => void) => {
  let buffer = '';

  return (chunk: Buffer) => {
    buffer += chunk.toString();
    if (buffer.includes('\r\n\r\n')) {
      const response = handleRequest(buffer);
      if (socket.writable) {
        socket.write(formatHttpResponse(response));
        socket.end();
      } else {
        logger.error('Socket is not writable, skipping response');
      }
    }
  };
};

Explanation of `createDataHandler` Function

createDataHandler is a function that handles incoming TCP data chunks for HTTP requests. It maintains a buffer—a string that accumulates data from incoming chunks.

Chunk Conversion: For each chunk, it converts the binary data into a string and appends it to the buffer.
Header Detection: It then checks if the buffer contains \r\n\r\n, which marks the end of the HTTP headers.
Processing & Response: If it finds the marker, it processes the request and sends a response.

This gave me a clearer view of how HTTP works at the lowest level: every incoming request starts as raw data, and the server has to parse it into something usable. Sockets are the invisible ropes that pull these chunks back and forth, and the createDataHandler function is the intermediary which makes something sensible of the data.

We can also appreciate how fragile things are: if the buffer isn’t handled properly—by failing to detect the end of the headers, for example—the server breaks. These are things I've never appreciated when using frameworks.

Learning 2: Routing Isn’t That Simple

Manual routing turned out to be more challenging than I expected, especially when it came to handling content types. Frameworks like Express.js make this super easy, but behind the scenes, there’s a lot happening:

Content-Type Handling: My server only supported JSON for request bodies, and I had to set the correct MIME type manually for responses. Adding support for more content types, like multipart/form-data for file uploads or application/x-www-form-urlencoded for form submissions, would require additional parsing logic.
Headers Management: In a basic setup, you’re responsible for setting essential headers like Content-Type and Content-Length. Get these values wrong, and the client either won’t understand the response or will hang waiting for more data. This is what happened when my server was not picking up the images/jpeg datatype.
Parsing Body Formats: Each content type requires its own logic. For example, JSON bodies need to be parsed into JavaScript objects, while multipart/form-data requires handling file streams. This complexity grows quickly as you add support for more formats.

Express.js automates most of this. It detects the Content-Type header, parses the body accordingly, and sets the right MIME type for responses. Doing this manually gave me a deep appreciation for how much work frameworks save.

While my manual routing works for basic cases, it’s clear that scaling it to handle more complex scenarios would require more effort.

Learning 3: Always Try to Break Your Software

Software is rarely perfect the first time around. A great way to test my server was to run:

hey -n 1000 -m GET http://localhost:8080/

Stress Test Outcome

BOOM. The server crashed after 800 requests.

Why?

This command sends 1,000 simultaneous GET requests, simulating real-world stress. It exposed a critical issue: I wasn’t handling socket timeouts properly. My server would hang because it didn’t close idle sockets.

The Fix:

To fix this, I chose to close the socket after each request, which works great for the scope of this project. But if I wanted to support persistent connections, I’d need to avoid calling socket.end() and implement additional logic. For now, closing the connection after each request is the simplest and safest approach. It’s clean, predictable, and prevents resource leaks.

What’s Next?

There’s a lot more I can add to this server, which is also the reason why I love to start a project from ZERO. I get to own every bite of it and can add on to it as learning-needs/curiosity fit.

HTTPS: Right now, it’s plain HTTP. Adding SSL/TLS would make it secure.
WebSockets: For real-time communication, like chat apps.
Authentication: Handle user logins and sessions.
Better Routing: Add support for more content types and dynamically set MIME types based on file extensions or request content.
Caching: Improve performance by storing frequently requested data.

Why It Matters - Meta Learnings

I am a huge fan of Tim Ferriss, especially when it comes to his lessons on meta learning, or the ability to learn pretty much everything and become a top performer in any field in a short period of time.

Writing an HTTP server from scratch was a way to dig deeper into one of the fundamental building blocks of full-stack engineering—to deeply understand the web and servers. It was also interesting to see how constraints (not using a framework like Express) force you to think critically and solve problems creatively, which of course deepens my understanding. Last but not least, there’s simply a unique joy in building something functional from scratch! 😃

You can check the project on GitHub!

Happy building!

How do you know you have enough data?

Manon — Sat, 14 Dec 2024 15:47:06 +0000

In the world of deep learning, a common question that arises is, “How do I know if I have enough data?” This is a crucial consideration because the quantity and quality of your data can significantly impact the performance of your model. However, knowing whether your dataset is sufficient isn’t always straightforward and requires a combination of practice and experimentation.

Check the model and ask yourself: is it good enough?

Before diving into data collection or augmentation efforts, it’s important to assess whether your current model is performing well enough. This involves evaluating its accuracy, loss, and generalization ability. If the model is not performing satisfactorily, it’s crucial to investigate whether the issue lies in the dataset size, diversity, or other factors like model complexity.

Key Questions to Ask:

Is the model overfitting or underfitting? Overfitting might indicate that the model is too complex for the available data. Underfitting suggests the model may be too simple or not trained enough.
How does the model perform on validation or test data? Consistent performance across training and validation sets can indicate sufficient data.

You Can’t Know If You Have Enough Until You Train the Model

The truth is, you can’t really know if you have enough data until you actually train the model. The process of training helps reveal whether your dataset is capturing the necessary features and patterns to achieve your desired level of performance. You may find that even a small dataset works well with certain problems, especially with the right techniques, like transfer learning or data augmentation.

Why Training Early is Key:

According to Jeremy Howard from Fastai, training early is the recommended approach when it comes to learning fast how your model is doing, and so if you have enough data:

Training early will give us immediate feedback on how well the model is learning, allowing for quick adjustments to data collection or model parameters, and it will allow us to iterate on our model design and data preprocessing steps, refining them based on initial results.

As new practitioner, we might spend excessive time gathering or preprocessing data without knowing if it’s even necessary. A better approach seems therefore to train on day 1 to see what kind of accuracy we can achieve with the existing data, and iterate from there. Key Takeaway: Avoid Waiting Too Long Before Training the Model!

Advantages of Training Early:

Experimentation: Training early enables experimentation with different models and hyperparameters, helping us to learn what works best for our specific problem.

Understanding data needs: Initial training results can inform whether more data is required or if our efforts should focus on optimizing other aspects of the model.

Avoiding wasted effort: We might find that a simple model trained on limited data achieves acceptable results, saving time and resources!

That being said, the great thing is that there are techniques available to maximise our data, ensuring we can build effective models even with limited datasets (yay!) - Techniques such as data augmentation, transfer learning, and regularization can significantly enhance model performance.

Techniques to maximise our data under constraint (without enough data for instance):

The great thing about deep learning is that there are numerous techniques to maximise our data, ensuring we can build effective models even with limited datasets (yay!) - Techniques such as data augmentation, transfer learning, and regularization can significantly enhance model performance.

Stay tuned for a separate article that will delve into these techniques, providing strategies and tips on how to make the most of our available data and improve model performance even with constraints.

Key takeaway: By training our model early and often, we can gain valuable insights into our data’s sufficiency and learn how to make informed decisions about data collection and preprocessing. This approach not only helps build better models but also makes our development process more agile and responsive.

Any tips on identifying if you have enough data?

Stay curious,
Manon

What Usain Bolt, Leibniz and Newton Have in Common?

Manon — Sat, 14 Dec 2024 15:32:26 +0000

When I first came across a mention of Usain Bolt, Leibniz, and Newton together on Khan Academy, it instantly sparked my attention, which makes me want to share it in return.

What could a legendary sprinter and two famous mathematicians have in common? It turns out the answer lies in the basics of calculus, which I realise is more relevant than I initially thought when learning deep learning and artificial intelligence mathematical concepts.

In the context of understanding how neural networks (really work), I logically found myself revisiting the basics of calculus. Oh joy! In this article, I'll share how these three seemingly disparate figures are linked through one obsession that is not only crucial in sports and physics but also, it turns out, in the rapidly evolving field of AI (I know, unbearable suspense!)

Asking a Fundamental Question

Bolt, Leibniz, and Newton were all obsessed with the same fundamental question, one that drives much of differential calculus: What is the instantaneous rate of change of something? This might sound abstract, but it's actually a question that pops up in many real-world situations.

Take Bolt, for example. We might be curious about how fast he’s running at any given moment during a race. Not just his average speed over a second or the next ten seconds, but his exact speed right now. This is precisely what differential calculus helps us figure out—it's all about understanding instantaneous rates of change, the speed of something at a specific moment in time.

At its core, the instantaneous rate of change is all about pinpointing how quickly something is happening at a specific moment. In simpler terms, it’s the speed of a process at one exact point in time. Imagine you're driving a car. While you might be interested in your average speed during a trip, you might also want to know how fast you’re going right now, as you glance at the speedometer. That’s an instantaneous rate of change—the speed of the car at that precise moment.

What Is an Instantaneous Rate of Change?

In mathematics, this concept is crucial because it allows us to move beyond averages and see what's happening in the moment. For athletes like Usain Bolt, it’s the difference between knowing his average speed over a race and understanding his top speed at any given instant. This idea isn't just limited to speed; it applies to any situation where change occurs—whether it’s the temperature outside, the stock market's rise and fall, or even how fast a neural network is learning during training.

Why is this concept so crucial in deep learning?

In mathematics, this concept allows us to move beyond averages and see what's happening in the moment. For athletes like Usain Bolt, it’s the difference between knowing his average speed over a race and understanding his top speed at any given instant. This idea isn't just limited to speed; it applies to any situation where change occurs—whether it’s the temperature outside, the stock market's rise and fall, or, and this is where my interests lie today: how fast a neural network is learning during training.

Calculate the average rate of change over [1, 3] - Khan Academy

What about Derivatives?

You might remember derivatives from your college classes. Personally, I definitely needed a refresher on that fundamental mathematical concept. Instantaneous rates of change and derivatives are deeply connected in calculus. A derivative, in simple terms, measures how a function changes as its input changes. It gives us the rate at which something is happening at any precise moment. So, if we were to graph Usain Bolt's speed over time during a race, the derivative of that graph at any given point would tell us his exact speed at that moment.

Derivatives are powerful because they allow us to move from knowing general trends to understanding specific details in real time.

Read that again.

Derivatives give us the insight needed to see how things are changing right now, not just on average, whether we are calculating Usain Bolt’s speed or fine-tuning the learning speed of a neural network.

Applied derivative example and why it matters in the context of deep learning

Let’s come back to why we arrived here in the first place: understand how neural net really work.

When we dive into the world of deep learning, derivatives become more than just abstract mathematical tools—they are in fact essential for training neural networks. In this context, derivatives are used to optimise the network by adjusting the weights of connections between neurons to minimise errors and improve performance.

Let’s consider how a neural network learns to recognise images.

During training, the network makes predictions and compares them to the actual outcomes. The difference between the prediction and the reality is calculated as an error. To reduce this error, the network uses a process called backpropagation, which relies on derivatives. By calculating the derivative of the error with respect to each weight in the network, we can determine how much each weight should be adjusted to improve the model's accuracy. This adjustment process is repeated many times, gradually tuning the network until it performs well.

In essence, and based on what I learned so far through the Fastai course and Andrej Karpathy’s youtube series, derivatives help guide the network’s learning process, making them indispensable in the development of AI systems. Without understanding and applying these instantaneous rates of change, the sophisticated models that drive advancements in machine learning and artificial intelligence would simply not be possible.

What we learned today:

Instantaneous rates of change and derivatives are crucial concepts that connect theoretical mathematics with real-world applications.

Derivatives allow us to move from understanding general trends to capturing specific, real-time details.

In deep learning, derivatives are essential for optimising and improving neural network performance.

The best takeaway for me is: ##We don’t need super advanced mathematical concepts to learn deep learning!## And that's a really good news.

Keep moving,
Manon 🦉

Fitting a function to data

Manon — Sat, 14 Dec 2024 15:16:26 +0000

The first time I heard about “Fitting a function to data“ in the fastai course, my brain went 🤯 - it turns out, fitting a function to data is a fundamental aspect in training models.

In the context of neural networks, “fitting a function to data” refers to the process of training a model to learn the underlying patterns, relationships, or mappings between input data and the desired output.

Let’s delve into this fundamental aspect of neural nets, why it’s essential, and how it is achieved in practice.

Understanding the Concept:

At its core, a neural network is a complex mathematical function designed to transform input data into output predictions. The objective of training, or fitting, is to adjust the function's parameters—namely, weights and biases—so that the network’s predictions closely align with the actual target values. This process of fine-tuning is crucial for the model to accurately reflect the relationships within the data.

What is a Function?

First things first. What is a function?

A function defines a relationship between a set of inputs and a set of possible outputs. When we talk about functions in machine learning, we're referring to this relationship in a specific context:

Input (X): The data we provide to the model (e.g., images, text, numerical features).

Output (Y): The prediction or classification that the model generates (e.g., labels, regression values).

In a neural network, the function is represented as f(X,θ)f(X, \theta)f(X,θ), where:

XXX is the input data.

θ\thetaθ represents the parameters (weights and biases).

fff is the model that maps inputs to outputs.

The goal of fitting the function is to adjust θ\thetaθ so that the function fff accurately captures the relationship between XXX and YYY.

Why Do We Fit a Function to Data?

Fitting a function to data is essential in neural networks for several reasons:

To Learn Patterns and Relationships

Discovering Hidden Structures: Data often contains complex patterns or relationships that aren’t immediately obvious. By fitting a function, a neural network can learn these structures and make sense of the data.

Feature Extraction: Neural networks have the ability to automatically learn and extract relevant features from raw data, reducing the need for extensive manual feature engineering.

To Make Predictions

Generalization: Once a neural network is trained, it should generalize well to unseen data, making accurate predictions based on the patterns it has learned.

Decision Making: The predictions made by a neural network can drive decision-making processes in various applications, such as self-driving cars, medical diagnosis, and financial forecasting.

To Better Optimization and Efficiency

Loss Minimization: The process of fitting involves minimizing a loss function, which quantifies the difference between predicted and actual values. The goal is to find parameter values that yield the lowest possible loss.

Efficient Representation: Neural networks can efficiently represent complex functions with relatively few parameters, making them well-suited for high-dimensional data.

How Does Fitting Work?

The process of fitting a function to data in a neural network involves several key steps that I tried to summarise below:

Step 1: Initialisation: The weights and biases of the network are initialised, often with small random values.

Step 2: Passing the data and first prediction: the Input data is passed through the network layers, with transformations applied based on the current parameter values to produce an output. The network then generates predictions for the given input data.

Step 3: Loss Calculation: We then apply a loss function (e.g., mean squared error, cross-entropy) to measure the difference between predicted and actual target values. This is a key step in fitting data into functions. We then can calculate Loss: the loss is computed for the given predictions, providing a metric for how well the network is performing.

Step 4: Back-propagation: Using backpropagation, the gradients of the loss with respect to each parameter are computed. This involves applying the chain rule to propagate errors backward through the network. This is called gradient calculation (best video on it I found here).

Step 5: Parameter Update: Parameters are updated using optimisation algorithms like stochastic gradient descent (SGD).

Step 6: Iteration, of course! The training process is repeated over multiple iterations (epochs) and different subsets of data (batches) to continuously refine the parameter values. The ultimate goal in the iterative process is to reach a convergence to a set of parameters that minimize the loss function, achieving a good fit to the training data.

Why Not Use Traditional Models like Linear Regression?

In the Fastai course, we use a simpler Linear Regression to fit a quadratic. This model fits simple functions to data, which prove to be insufficient for more complex tasks where:

Non-linearity: Data relationships are non-linear and require sophisticated functions to capture.

High Dimensionality: Inputs are high-dimensional (e.g., images, audio) and need complex architectures.

Complex Patterns: Patterns involve intricate interactions that simple models cannot capture effectively. Neural networks excel in these scenarios due to their ability to approximate complex functions.

What We Learned Today

Fitting a function to data is the process of training a neural network to learn the relationships between input data and the desired output.
A neural network functions is a complex mathematical model that adjusts its parameters (weights and biases) to minimise the difference between predictions and actual target values.
Fitting a function is essential for discovering hidden structures in data and making accurate predictions.
The process of fitting involves key steps: initialisation, forward pass, loss calculation, backpropagation, and iterative optimisation.
Traditional models like linear regression may not be sufficient for complex, non-linear, and high-dimensional data, where neural networks excel.

Stay curious!

Manon 🦉

A Quick and Comprehensive Guide On Which Database to Use in your next Fullstack Application

Manon — Mon, 26 Feb 2024 17:49:07 +0000

In the ever-evolving world of technology, we can safely say that there is this one constant (🥳), the backbone of most applications — whether they're your go-to weather app or the database managing global transactions — is the database management system (DBMS) they rely on. Building fullstack applications made me want to gather in one place my notes and takeaways from different databases, which hopefully will also help you see clearer, and make an informed decision on which database to use, and why.

So this is a short and sweet guide on the main three databases most used today: SQLite, PostgreSQL, and MongoDB. Each of these powerhouses offers unique features, advantages, and typical use cases. Let's dive in!

SQLite - The Lightweight Champion 🕊️

Imagine a tiny, yet mighty warrior—that's SQLite! It's the database equivalent of having a Swiss Army knife in your pocket. It is designed to be embedded within the application it powers: SQLite is a self-contained, disk-based database that doesn't fuss over needing a separate server process.

Pros:

Lightweight and Portable: Effortless setup, ideal for constrained environments.
No Installation Needed: Seamless integration with applications, simplifying deployment.
Reliable and Accessible: A robust storage solution that's straightforward to manage.

Cons:

Limited Scalability: Not the best fit for high-traffic scenarios or concurrent writes.
Fewer Features: Misses out on some advanced functionalities of more complex systems.

Famous Use Case:

Apple makes extensive use of SQLite across macOS and iOS, embedding it within various system functions and applications, showcasing its reliability and efficiency.

PostgreSQL: The Robust Workhorse 🏋️‍♂️

Here we are dealing with object-relational database system that's all about reliability, robust features, and performance. It's like having a reliable workhorse that can carry heavy loads without breaking a sweat. PostgreSQL shines then in enterprise applications, web services, data warehousing, or geospatial databases thanks to its scalability and advanced features.
A big plus for PostgreSQL is that it's open-source 😎

Pros:

Highly Scalable: made to handle large datasets and numerous concurrent users.
Advanced Features: Rich in functionalities like complex queries and transactions.
Extensibility: Custom data types and functions for tailored solutions.

Cons:

Complexity: Its sophistication can be a hurdle for smaller teams or projects.
Resource Intensive: Requires a significant investment in hardware and upkeep.

Famous Use Case:

:drum-roll: Instagram!

MongoDB: The Agile NoSQL 🐐

Finally, let's talk about MongoDB, the NoSQL database that's all about flexibility and speed. Picture a gymnast performing a flawless routine—graceful, flexible, and powerful. That's MongoDB, storing data in flexible, JSON-like documents which allows fields to vary and data structure to change over time. It's perfect for big data applications, content management systems, and mobile apps requiring real-time data.

Pros:

High Performance: Designed for rapid data retrieval and large data volumes.
Scalability: Sharding capability for distributing data across servers.
Flexible Schema: Adapts to polymorphic data, perfect for changing data models.

Cons:

Awkward Joins: Performing joins is less straightforward than in relational databases.
Memory Usage: Potentially high, which could be restrictive in certain environments.

Famous Use Case:

Meta utilizes MongoDB for its diverse set of applications.

Making the Choice

Choosing between SQLite, PostgreSQL, and MongoDB isn't about picking the best database overall — it's about finding the best fit for your project's needs. If simplicity and ease of use are paramount, SQLite might be your best choice. For projects requiring data integrity, complex queries, and scalability, PostgreSQL stands ready to support you in that. And for scenarios demanding flexibility, scalability, and high performance, especially with large volumes of unstructured data, MongoDB might be the way to go.

Thanks for reading, and happy coding 👋

8 Plugins You Should Add To Your IDE And Why

Manon — Fri, 16 Feb 2024 12:49:34 +0000

First and foremost, I am using WebStorm. I know. I am paying for my licence. Why? Because I find it extremely powerful in terms of performance, typing, and debugging capabilities. I am also used to its shortcuts now, which makes it hard for me to switch to VSC (and believe me, I’ve tried many times!)

The nice thing about WebStorm is also that it has all the plugins you need coming out of the box. You then end up adding very specific plugins you need, and that’s it.

Note: I recommend to disable the plugins you won’t need for your projects though. For example, if you are a React developer, it’s pretty safe to say that you won’t need the Angular plugin. Just go to Settings -> Plugins -> Installed, and disable it. A clean working environment is a powerful environment ;)

So, what are the plugins that I am using?

.ignore: is a plugin for all .[something]ignore you can think of: .eslintignore, .dockerignore , .vercelignore , .gitignore …it will help with syntax highlighting, suggesting new .gitignore files on a project, support comments and brackets, or entries inspections with quick-fix proposals. You can see the full list of feature here!
.env files support: isn’t annoying that you cannot just go to declaration (in .env file) and usages (in code) just by hitting a shortcut command? With this plugin, you can 🙏 — This plugin also helps with autocompletion on environment variables, which is pretty convenient.
Wakatime: this one is not for everyone. Only for the metrics lovers 🙈 As it turns out, there are a lot of metrics lovers among us, developers (shocker): in 2023, more than 500k developers spent a combined 51 million hours programming, all tracked with WakaTime plugins 🤯 — so, if you don’t use it already, give it a try!
Rainbow Bracket: because honestly, who never got crazy trying to find the start and the end of endless divs???
Prisma ORM: this is obviously if you are using Prisma in your project. I started to experiment with it recently as my data models and data queries to Mongo, it works great. This plugin will make your experience even better as you won’t have to go to your terminal or to the Prisma interface in your browser, no, you’ll be able to interact with Prisma and your backend directly from WebStorm 😎
Github copilot. You can check the github page if you want to know more about its powerful capabilities. Some developers — IMO the hard core developers — will tell you copilot is a bad thing to use, but honestly, it allows me to be much faster and to spend time on the trickier part of the code, not the trivial ones AI can help me with. So, just give it a try and take it with a pinch of salt. You will still be a good developer even if you are using the help of AI ;)
MDX: not a must, but very convenient if you are using this format that combines Markdown and Javascript. It is especially useful if you want to write markdown inside React components since it allows to write JSX in markdown content. This plugin therefore helps me save time thanks to its code completion and syntax highlighting.

And that’s it! I’d love to hear in the comments what plugins do you find the most useful in your projects?

Happy coding! 🌞

Add storybook to your SvelteKit app

Manon — Mon, 27 Jun 2022 18:02:52 +0000

Pre-requisites:

have a SvelteKit project. You cannot install Storybook on an empty project.

Step 1: at your root project, run npx storybook init. During the installation, you will be asked if you want to run the 'eslintPlugin' migration on your project? Say yes. This is needed for the best Storybook experience.

Step 2: npm run storybook
You will probably get an [ERR_REQUIRE_ESM] error, something like this:

Fix:

in .storybook, rename your main.js file to main.cjs
in main.cjs file, replace this line "preprocess": require("../svelte.config.js").preprocess with preprocess: import('../svelte.config.js').preprocess.

Et voila! Enjoy 🙌

4 simple steps you can take now to improve your TypeScript codebase

Manon — Wed, 17 Feb 2021 19:46:39 +0000

Because in an ideal world, readability and maintainability would be the north star of every programmer.

TL;DR

Make your TS Config as strict as possible so you can agree on naming conventions, avoid typing errors, etc
Use a linter and formatter tool so your team can focus on the real deal
Agree on a project architecture
Leverage the power of pair programming to solve complex issues

Don't try to abstract so much that your teammate (and, most likely, your future self) cannot understand your code later. When working within a team, often the most critical issue is to read and understand other people's code. Focusing on readability and maintainability will not only help you read and refactor your code in two months from now, but it will also help the whole team to be more productive, efficient, and, overall, happy!

Readable and maintainable codebases are also key when it comes to scaling your application. When starting a new project, it is better to start simple and small with strong and clear foundations rather than over-engineering your application without even knowing where your project will be in a few months from now.

But what can you do to make readability and maintainability your north star?

1. Make your TS Config as strict as possible

If you can, make your TS Config strict. You might have tons of errors, to begin with, but this is worth it as you will enjoy all the benefits of better type safety.
Here are some of the most useful rules you can enable in your TSconfig file:

"strict": the strict flag will enable a wide range of type checking, therefore, resulting in stronger guarantees of program correctness. If you turn this on, you will enable all of the strict mode family options. If you want to enable only some of the strict family (see below), it is not necessary to enable strict.

"strictNullChecks": set this rule to truewill save you a considerable amount of Javascript errors; especially the much-loved runtime error 'undefined' is not a function , frequently caused by bugs in JavaScript code. With strictNullChecksenabled, TypeScript won't allow you to use a variable that is not known to the compiler (an exception is to be made with the use of any typed variables, more on this later).

"strictBindCallApply": this rule is also super useful as it will check that the built-in methods of functions call, bindand apply are correctly invoked.

"strictFunctionTypes": if enabled, function parameters are checked more correctly. However, this rule doesn't apply to functions written in the method syntax, only for function syntax.

"forceConsistentCasingInFilesNames": enabling this rule will be useful if you are working on a project where developers use different OS because it will prevent issues related to the file casing and how the files are referenced in the code. TypeScript will thus issue an error if a program tries to include a file with a casing different from the casing on disk.

"noImplicitAny": TypeScript will issue an error whenever it would have found a type any. This rule is really strict and probably hard to implement in large codebases or codebases transitioning to TypeScript.

"noImplicitThis": TypeScript will raise an error if your code has implied any type of "this" expression.

"noImplicitReturns": if you enable this rule, TypeScript will check all code paths in a function to ensure they actually return a value.

"noUnusedParameters": enabling this will raise errors on unused parameters in functions.
For full reference, you can check the official documentation here.

2. Use a linter and formatter tool

Why is it so critical to have a TypeScript code that is readable, well-formatted, and clean? Because it will allow programmers to focus on what they do best and enjoy the most: implement business logic, improve performance, enhance the architecture of a codebase, build a UI library… you name it!
Using a linter and formatter tool (ESlint, Prettier…) will provide consistency to your codebase and make your team happier. And, we all know that a happy team is an efficient one! By keeping your TypeScript clean with linters and formatters, you are avoiding long debates among programmers regarding missing semi-colons or indentation (oh, joy!)

Your codebase will become:

easier to read and start with for new joiners
easier to review
easier to refactor
a happier place where programmers have fewer frictions

3. Agree on a project architecture

As Daniel Irvine pointed out in this article, 'almost always the biggest problem I see is interpersonal issues that stem from disagreements about project direction and structure.'

If you are working on a solo project or within a team, you will always be rewarded if you agree and follow a clear project structure. This will allow you to:

onboard new joiners more easily
navigate your project in a structured and clear way
find relevant files faster
better refactor your code as it will be easier to see the bigger picture within your project
overall, enhance your productivity and happiness with working on your project

4. Use the power of pair programming to solve complex issues

Why should you consider pairing with a teammate more often? For many good reasons!

It's fun and creates bonding within a team, which is not to be neglected as it will most likely improve the overall codebase in the long run.
It allows a faster and better spread of knowledge among teams, especially if the programmer leading the session is familiar with a part of the codebase the other teammate is not.
Along with the same idea, pair programming will allow a better transfer of skills towards junior developers as they can pick-up tips and tricks from more experienced developers, leading to faster growth.
Usually, when pair programming, you and your teammate are programming 'out loud', which ultimately leads to discover hidden items in the code and to a clearer understanding of the complexities.

Thanks for reading, and happy coding! 😀

Forem: Manon

From TypeScript to Rust: Navigating Memory Safety Challenges

Implementing a Linked List in Rust, it turns out, is a tough one.

How do we implement a linked list in Rust?

Want to be a better full-stack developer? Know the web and HTTP principles

Contents

Why Build a HTTP server from Scratch?

First, the basics. What Is an HTTP Server?

TCP vs. UDP

Key features of my HTTP Server (Typescript + Nodejs)

What I Learned

Learning 1: Sockets!

Explanation of createDataHandler Function

Learning 2: Routing Isn’t That Simple

Learning 3: Always Try to Break Your Software

Stress Test Outcome

What’s Next?

Why It Matters - Meta Learnings

How do you know you have enough data?

Check the model and ask yourself: is it good enough?

Key Questions to Ask:

You Can’t Know If You Have Enough Until You Train the Model

Why Training Early is Key:

Advantages of Training Early:

Techniques to maximise our data under constraint (without enough data for instance):

What Usain Bolt, Leibniz and Newton Have in Common?

Asking a Fundamental Question

What Is an Instantaneous Rate of Change?

Why is this concept so crucial in deep learning?

What about Derivatives?

Derivatives are powerful because they allow us to move from knowing general trends to understanding specific details in real time.

Applied derivative example and why it matters in the context of deep learning

What we learned today:

Fitting a function to data

Understanding the Concept:

What is a Function?

Why Do We Fit a Function to Data?

To Learn Patterns and Relationships

To Make Predictions

To Better Optimization and Efficiency

How Does Fitting Work?

Why Not Use Traditional Models like Linear Regression?

What We Learned Today

A Quick and Comprehensive Guide On Which Database to Use in your next Fullstack Application

SQLite - The Lightweight Champion 🕊️

Pros:

Cons:

Famous Use Case:

PostgreSQL: The Robust Workhorse 🏋️‍♂️

Pros:

Cons:

Famous Use Case:

MongoDB: The Agile NoSQL 🐐

Pros:

Cons:

Famous Use Case:

Making the Choice

8 Plugins You Should Add To Your IDE And Why

Add storybook to your SvelteKit app

4 simple steps you can take now to improve your TypeScript codebase

1. Make your TS Config as strict as possible

2. Use a linter and formatter tool

3. Agree on a project architecture

4. Use the power of pair programming to solve complex issues

Explanation of `createDataHandler` Function