The Angry Dev

Windows 10 Is Dying, but Gaming (and working) on Linux Is Easy

Tue, 07 Oct 2025 10:08:00 +0100

Microsoft is officially ending support for Windows 10 in October 2025, and for millions of PC users, that sounds like bad news, because you may not have the right hardware for Windows 11, or you may not want all of your personal data vacuumed up by Microsoft. But here’s the twist: you don’t have to buy new hardware or upgrade to Windows 11 just to keep playing your favorite games.

Thanks to modern Linux distributions like Ubuntu, gaming on Linux is now shockingly simple. You can install it in under an hour, play your Steam and Epic Games library, and even do your everyday work… All without touching the command line.

Why Linux Is Perfect for Gaming and Work in 2025

Linux has come a long way. Thanks to tools like Steam’s Proton and Heroic Games Launcher, it can now run most popular PC games, including those from Windows only platforms (with exceptions for games that require kernel mode anti-cheat such as Fortnite and Apex Legends for now). You also get powerful office software, web browsers, and creative tools which are all free and easy to install.

Let’s go step by step through how to set up a complete Linux system that’s ready for both gaming and work.

Step 1: Install Ubuntu

If you’re new to Linux, start with Ubuntu. It’s one of the most beginner friendly versions, designed for everyday users and gamers alike.

How to install Ubuntu:

Go to ubuntu.com.
Download the latest LTS (Long Term Support) version as this gets updates for five years before you update to the new LTS.
Use a tool like Rufus (on Windows) or balenaEtcher (on Mac/Linux) to create a USB installer.
Boot your computer from the USB stick and select “Try or Install Ubuntu."
Follow the simple on screen installation steps.

You can even try Ubuntu before installing it, just choose “Try Ubuntu” to see how it feels (other beginner friendly Linux distributions to look at are Linux Mint or ZorinOS Core, both of which have a much more Windows like appearance).

Step 2: Keep Ubuntu Updated (No Command Line Needed)

After installation, click the Software Updater icon in the app menu or dock. Ubuntu will automatically check for updates, just click Install Now when prompted.

Your system stays secure and up to date, no manual steps or terminal commands required.

Step 3: Install Steam on Linux for Gaming

Steam runs natively on Linux, and with Proton, you can play thousands of Windows only titles.

To install Steam:

Open the App Center (orange shopping bag icon).
Search for Steam.
Click Install, then Open when it’s ready.
Sign in to your Steam account.

Once inside Steam:

Go to Settings → Compatibility.
Check “Enable Steam Play for all other titles.”
Select the latest version of Proton.

Now you can install and play your Steam library. Games like Baldur’s Gate 3, Cyberpunk 2077, No Man’s Sky, and Elden Ring work great on Linux.

Step 4: Use Heroic Games Launcher for Epic Games and GOG Titles

If you have games from Epic Games, GOG, or Amazon Prime Gaming, the Heroic Games Launcher makes them playable on Linux too.

To install Heroic:

Visit heroicgameslauncher.com.
Download the Ubuntu (.deb) file via github (amd64 deb version) or, download the latest version at the time of writing by clicking this link.
Double click the file to open it in the App Center, then click Install.

Open Heroic from your applications menu, log into your Epic or GOG account, and download your games. Heroic handles the compatibility automatically, just click Play.

Step 5: Install Google Chrome on Ubuntu

Ubuntu includes Firefox by default, but if you prefer Google Chrome, it’s just as easy to install:

Go to google.com/chrome using Firefox.
Click Download Chrome.
Choose the .deb for Ubuntu option.
Once downloaded, double click and select Install.

Chrome will appear in your app menu and will update automatically through Ubuntu’s software updater.

Step 6: Use LibreOffice for Work (or Install It If Missing)

Ubuntu usually includes LibreOffice, a full featured office suite compatible with Microsoft Word, Excel, and PowerPoint files.

To check:

Open the App Menu and look for LibreOffice Writer (for documents) or Calc (for spreadsheets).
If it’s not there, open the App Center, search for LibreOffice, and click Install.

LibreOffice supports .docx, .xlsx, and .pptx formats and even exports to PDF. It’s fast, free, and ideal for daily work.

Step 7: Add Essential Apps for Everyday Use

Here are a few more great apps available directly from the App Center:

Discord – Chat and game with friends.
VLC Media Player – Watch videos in any format.
OBS Studio – Stream or record gameplay.

You can install everything with a few clicks, no need to search for downloads or type commands.

Step 8: Enjoy Your New Linux Setup

You’re done! You now have:

A secure, stable operating system.
Access to thousands of PC games via Steam and Heroic.
Full productivity tools (LibreOffice and Chrome).
No upgrade fees, no license keys, and full control over your system.

Linux today isn’t just for tech experts, it’s for anyone who wants speed, reliability, and freedom from Microsoft.

Why Event Driven Systems Are Not That Hard

Tue, 16 Sep 2025 12:42:34 +0100

Having recently read the article “Why are Event Driven Systems Hard?”, and having worked on several event driven systems myself, I began to wonder why people so often frame these systems as inherently difficult. It’s true that event driven and distributed systems can be hard to work with… especially if approached without the right mindset or tooling, but that doesn’t mean they are hard by default.

In fact, many of the “hard parts” that architects and developers worry about such as eventual consistency, debugging asynchronous flows and ensuring reliability, are well understood and largely solved with modern practices. With the dotnet ecosystem (or any other mature ecosystem), frameworks, and observability platforms, implementing event driven systems has become far more approachable than it was even a few years ago. The gap between theory and practice has narrowed significantly, making these architectures not only manageable but often the most straightforward option for scaling, decoupling, and evolving complex applications.

I am going to focus on dotnet, because that is what I know… Here we go:

Publishing and Handling Events Isn’t Hard

In dotnet, you don’t need to reinvent the wheel. Frameworks like MediatR, MassTransit, and NServiceBus make event publishing and consumption straightforward.

Example: Publishing a Domain Event with MediatR

// Define an event
public record OrderPlacedEvent(Guid OrderId, string CustomerEmail) : INotification;
// Publish event from domain service
public class OrderService
{
private readonly IMediator _mediator;
public OrderService(IMediator mediator)
{
_mediator = mediator;
}
public async Task PlaceOrder(Guid orderId, string customerEmail)
{
// business logic...
 await _mediator.Publish(new OrderPlacedEvent(orderId, customerEmail));
}
}
// Event handler
public class SendEmailOnOrderPlaced : INotificationHandler<OrderPlacedEvent>
{
public Task Handle(OrderPlacedEvent notification, CancellationToken cancellationToken)
{
Console.WriteLine($"Email sent to {notification.CustomerEmail} for Order {notification.OrderId}");
return Task.CompletedTask;
}
}

This looks almost like in-process events, but can later evolve into distributed event handling with minimal refactoring.

Distributed Messaging Made Easy with MassTransit

If you need cross-service messaging, MassTransit (with RabbitMQ, Azure Service Bus, or Kafka) removes a lot of plumbing.

Publishing an Event (Producer)

public class OrderController : ControllerBase
{
private readonly IPublishEndpoint _publishEndpoint;
public OrderController(IPublishEndpoint publishEndpoint)
{
_publishEndpoint = publishEndpoint;
}

 [HttpPost("orders")]
public async Task<IActionResult> CreateOrder(CreateOrderRequest request)
{
var orderId = Guid.NewGuid();
await _publishEndpoint.Publish(new OrderPlacedEvent(orderId, request.CustomerEmail));
return Ok(orderId);
}
}
public record OrderPlacedEvent(Guid OrderId, string CustomerEmail);

Consuming an Event (Consumer)

public class OrderPlacedConsumer : IConsumer<OrderPlacedEvent>
{
public async Task Consume(ConsumeContext<OrderPlacedEvent> context)
{
var evt = context.Message;
Console.WriteLine($"[Consumer] Sending welcome email to {evt.CustomerEmail}...");
await Task.CompletedTask;
}
}

MassTransit wires up consumers, retries, error queues, and observability out of the box. You don’t have to build these yourself.

Reliability Isn’t Hard: Use the Outbox Pattern

A common complaint is “What if the event is lost between DB and message bus?” The Outbox pattern ensures events are persisted with your data in the same transaction.

EF Core Outbox Example

// Entity with outbox entries
public class OutboxMessage
{
public Guid Id { get; set; }
public string Type { get; set; }
public string Payload { get; set; }
public DateTime OccurredOn { get; set; }
public bool Processed { get; set; }
}
// Save event inside same transaction
public async Task PlaceOrder(DbContext db, Guid orderId, string customerEmail)
{
var order = new Order { Id = orderId, CustomerEmail = customerEmail };
db.Orders.Add(order);
var evt = new OrderPlacedEvent(orderId, customerEmail);
var outbox = new OutboxMessage
{
Id = Guid.NewGuid(),
Type = evt.GetType().Name,
Payload = JsonSerializer.Serialize(evt),
OccurredOn = DateTime.UtcNow
};
db.Add(outbox);
await db.SaveChangesAsync();
}

A background service later reads unprocessed OutboxMessages, publishes them to the bus, and marks them processed. Libraries like EntityFrameworkCore.Outbox already implement this.

Reliability is solved with a proven pattern.

Observability Isn’t Hard with OpenTelemetry

Tracing async events can feel tricky, but OpenTelemetry for dotnet integrates with MassTransit, Kafka, RabbitMQ, and Azure Service Bus.

builder.Services.AddOpenTelemetry()
.WithTracing(tracerProviderBuilder =>
{
tracerProviderBuilder
.AddAspNetCoreInstrumentation()
.AddMassTransitInstrumentation()
.AddHttpClientInstrumentation()
.AddJaegerExporter(options =>
{
options.AgentHost = "localhost";
options.AgentPort = 6831;
});
});

Every published and consumed event now gets correlated spans in Jaeger/Zipkin/Grafana Tempo.

Schema Contracts Aren’t Hard with AsyncAPI

Instead of “wild west” event schemas, dotnet teams can adopt AsyncAPI to describe event contracts, similar to Swagger for REST.

Example OrderPlacedEvent AsyncAPI snippet:

components:
messages:
OrderPlacedEvent:
contentType: application/json
payload:
type: object
properties:
orderId:
type: string
format: uuid
customerEmail:
type: string

Tools like NSwag + AsyncAPI generator can auto-generate C# contracts from this spec, removing guesswork.

Debugging Isn’t Hard with Event Stores

If you want full auditing and replayability, libraries like EventStoreDB integrate smoothly with dotnet.

// Append to stream
await eventStore.AppendToStreamAsync(
$"order-{orderId}",
StreamState.Any,
new[] { new EventData(Uuid.NewUuid(), "OrderPlaced", JsonSerializer.SerializeToUtf8Bytes(evt)) }
);
// Read back
var events = eventStore.ReadStreamAsync(Direction.Forwards, $"order-{orderId}", StreamPosition.Start);
await foreach (var resolvedEvent in events)
{
Console.WriteLine($"Event: {resolvedEvent.Event.EventType}");
}

Debugging means you can replay from the event log, no mystery black box.

Summary

Event driven systems don’t have to be hard when you leverage the right patterns and libraries:

MediatR: simple in-process events, evolves to distributed.
MassTransit / NServiceBus: cross-service pub/sub with retries, DLQs, observability baked in.
Outbox pattern: guarantees no event loss.
OpenTelemetry: distributed tracing across async boundaries.
AsyncAPI / NSwag: enforce clear event contracts.
EventStoreDB: full event sourcing + replay for debugging.

With these tools, most of the “hard” parts are already solved, so you can focus on domain modeling and business outcomes, not plumbing.

How to Upgrade Windows 10 to Windows 11 on Unsupported Hardware (Step-by-Step with Rufus)

Thu, 11 Sep 2025 13:25:45 +0100

If your computer doesn’t meet Microsoft’s system requirements for Windows 11, you may have seen the dreaded message: “This PC can’t run Windows 11.” The usual culprits are missing TPM 2.0, no Secure Boot, or an older CPU.

But here’s the good news: you can still upgrade Windows 10 to Windows 11 on unsupported hardware using a free tool called Rufus. This method avoids complicated registry edits and gives you a cleaner installation experience.

In this guide, I’ll show you step by step how to install Windows 11 on unsupported PCs using Rufus.

Before You Start: Important Note

This method works well, but keep in mind:

Microsoft does not officially support Windows 11 on unsupported hardware.
You may not receive future feature updates automatically.
Security updates could be limited in the future.
Always back up your files before starting the upgrade.

What You Need to Upgrade to Windows 11 with Rufus

To follow this tutorial, make sure you have:

A USB drive with at least 8GB of storage
The latest version of Rufus (free download)
The official Windows 11 ISO file from Microsoft
A PC currently running Windows 10

Step 1: Download Rufus and the Windows 11 ISO

Go to the Rufus website and download the newest version.
Visit the Microsoft Windows 11 download page.
Choose Download Windows 11 Disk Image (ISO) and save the file.

Step 2: Create a Bootable Windows 11 USB with Rufus

Now let’s prepare the installation media:

Insert your USB drive into your computer.
Open Rufus.
Under Device, select your USB drive.
Under Boot selection, browse and select the Windows 11 ISO you downloaded.

When you choose the ISO, Rufus will display customization options that let you bypass Windows 11 requirements. These include:

Remove requirement for TPM 2.0
Remove requirement for Secure Boot
Remove requirement for RAM and CPU checks

Tick the options that apply to your situation (or to be safe, just tick all three).

Click Start, and Rufus will create a bootable USB installer that bypasses all hardware checks.

Step 3: Upgrade from Windows 10 to Windows 11

Once Rufus finishes:

Open your new USB drive in File Explorer.
Run setup.exe.
Select Keep personal files and apps if you want to upgrade without losing your data.
Accept the warning about unsupported hardware.

Windows 11 will now install on your PC, even if it doesn’t meet Microsoft’s official system requirements.

Step 4: Enjoy Windows 11 on Unsupported PCs

When your computer restarts, you’ll be greeted with Windows 11 running smoothly on your previously unsupported hardware.

A few things to remember:

You should still receive security updates from Microsoft.
Major feature updates may require repeating this process.
Always keep a backup of important files, just in case.

Final Thoughts

Upgrading from Windows 10 to Windows 11 on unsupported hardware with Rufus is one of the easiest and safest methods. It removes the need for registry hacks and gives you control over which requirements to skip.

If you’ve been waiting to try Windows 11 but your PC isn’t supported, Rufus makes it possible in just a few clicks.

Why UUIDs Beat Integers as Primary Keys (And Why Performance Isn’t the Issue)

Mon, 08 Sep 2025 22:53:04 +0100

One of the first schema decisions you face when designing a database table is: Should I use an INT or a UUID as the primary key?

Most developers default to an auto-incrementing integer. It’s simple, compact, and familiar. But UUIDs (a.k.a. GUIDs) are increasingly popular — and many of the old performance objections don’t hold up with modern hardware.

Let’s break this down like developers, not DB theorists.

What’s a UUID, Really?

At the end of the day, a UUID is just a number. Specifically: a 128-bit number.

Compare that to the types you already know:

Type	Size (bits)	Size (bytes)	Max Values
`INT`	32	4	~4.3B
`BIGINT`	64	8	~9.2 quintillion
`UUID`	128	16	~3.4 × 10³⁸

That’s it. No magic. Just more space.

Why Developers Like UUIDs

1. Generate Anywhere

With integers, the database usually assigns the ID:

CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(50)
);

You don’t know the ID until after the row is inserted. With UUIDs, you can generate the ID in your application:

CREATE TABLE users (
id UUID PRIMARY KEY,
name VARCHAR(50)
);

Then in code:

import uuid
user_id = uuid.uuid4()

No database round trip just to get a key.

2. Merge Without Collisions

If you’ve ever tried merging data from two databases that both used AUTO_INCREMENT, you know the pain of ID collisions.

-- From DB A
id | name
---+-------
 1 | Alice
2 | Bob
-- From DB B
id | name
---+-------
 1 | Charlie
2 | Dana

Good luck merging those.

With UUIDs:

id | name
-------------------------------------+-------
550e8400-e29b-41d4-a716-446655440000 | Alice
ddeb27fb-d9a0-4624-be4d-4615062daed4 | Bob
d8f1f8d4-4b0f-11ee-be56-0242ac120002 | Charlie
42c9aeea-4b0f-11ee-be56-0242ac120002 | Dana

No collisions. Merge away.

3. Safer URLs

Ever seen a URL like /user/12345? Anyone can guess /user/12346.

UUIDs make this harder:

/user/550e8400-e29b-41d4-a716-446655440000

Much less guessable.

The Performance Myth

Here’s the common objection:

“But UUIDs are so much bigger than integers. Won’t that kill performance?”

Not really.

INT = 4 bytes
BIGINT = 8 bytes
UUID = 16 bytes

That’s 12 extra bytes per row compared to an INT. For perspective, a single VARCHAR(255) column can take 255 bytes — orders of magnitude more than the difference between keys.

Modern CPUs handle 128-bit comparisons natively. Databases already juggle kilobytes of row data per query. The cost of comparing two UUIDs instead of two integers is microscopic compared to disk I/O, joins, or network latency.

Real-world bottlenecks are almost never the 16-byte key.

Things to Watch Out For

That said, UUIDs aren’t free candy:

Bigger indexes → Indexes on UUID columns take more space. If you’re storing billions of rows, that matters.
Fragmentation → Random UUIDs don’t insert sequentially. This can cause page splits in clustered indexes. Solutions: use UUIDv1 or database-specific functions like UUID_TO_BIN() (MySQL) that produce more sequential values.
Readability → Debugging 12345 is easier than 550e8400-e29b-41d4-a716-446655440000. Most teams solve this with tooling/log formatting.

Rule of Thumb for Developers

Use INT or BIGINT if:
- Your app is small and won’t need cross-database merges.
- You want compact storage and don’t care about guessable IDs.
Use UUID if:
- You’re building distributed or microservice systems.
- You need to merge data from multiple sources.
- You want to generate keys outside the database.
- You want harder-to-guess identifiers.

Benchmark: `INT` vs `UUID` in PostgreSQL

Let’s test with two identical tables:

-- INT-based table
CREATE TABLE users_int (
id SERIAL PRIMARY KEY,
name TEXT
);
-- UUID-based table
CREATE TABLE users_uuid (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
name TEXT
);

We’ll insert 1 million rows into each:

-- Insert into INT table
INSERT INTO users_int (name)
SELECT 'user_' || g
FROM generate_series(1, 1000000) g;
-- Insert into UUID table
INSERT INTO users_uuid (name)
SELECT 'user_' || g
FROM generate_series(1, 1000000) g;

Query Performance

Point lookup by primary key:

EXPLAIN ANALYZE
SELECT * FROM users_int WHERE id = 500000;

Output (abridged):

Index Scan using users_int_pkey on users_int
(cost=0.42..8.44 rows=1 width=36)
(actual time=0.018 ms)

Now with UUID:

EXPLAIN ANALYZE
SELECT * FROM users_uuid
WHERE id = '550e8400-e29b-41d4-a716-446655440000';

Output (abridged):

Index Scan using users_uuid_pkey on users_uuid
(cost=0.42..8.44 rows=1 width=52)
(actual time=0.019 ms)

The difference? Basically zero. Both queries run in ~0.02ms.

Index Size

Let’s compare index sizes:

SELECT
relname AS index_name,
pg_size_pretty(pg_relation_size(indexrelid)) AS index_size
FROM pg_stat_all_indexes
WHERE relname LIKE 'users_%_pkey';

Sample output:

index_name	index_size
users_int_pkey	35 MB
users_uuid_pkey	70 MB

Yes, the UUID index is bigger (about double, which makes sense: 16 bytes vs 8). But even at 1 million rows, we’re only talking tens of MB — trivial on modern systems.

Takeaway for Developers

Lookup speed: Identical.
Insert speed: Nearly identical (UUIDs may fragment clustered indexes if totally random, but UUIDv1/sequential UUIDs solve this).
Storage: UUIDs take more index space, but unless you’re working with billions of rows, it’s not the bottleneck.

The actual performance bottlenecks will almost always be query design, joins, and I/O — not whether your primary key is 4 bytes or 16.

So when someone says “UUIDs are slow”, you can point at query plans and actual numbers: they’re not.

TL;DR

A UUID is just a 128-bit number, the same way an INT is a 32-bit number.
The performance hit is negligible on modern hardware.
UUIDs unlock distributed key generation, collision-free merges, and safer URLs.
Integers are fine for simple, single-database apps — but UUIDs future-proof your schema.

The Lie You Are Being Told About AI and Junior Developers

Tue, 19 Aug 2025 13:32:57 +0100

Let’s get one thing straight. If you’ve been listening to the so-called “tech futurists” and clueless CEOs, you’ve probably been fed the same line: AI is going to replace every entry-level developer.

It’s a hot take for a podcast, a great headline for a tech bro’s newsletter, and an even better way to get a company’s stock price to jump. But it’s also a complete, unadulterated lie. And it’s time to call it out for what it is.

AI is not a replacement for junior developers. It’s not a silver bullet that eliminates the need for human talent. It’s a tool. It’s an assistant. Anyone who tells you otherwise either doesn’t understand software development or is trying to sell you something.

The Uncomfortable Truth: AI Needs a Pilot

The people who think AI will replace junior developers fundamentally misunderstand what coding is. They believe it’s just typing, like a human word processor. They see an AI spit out a block of code and think, “Great, problem solved. I don’t need that junior dev anymore.”

This kind of thinking is dangerous and naive.

Think of a junior developer as a pilot in training. The AI is the autopilot—incredibly sophisticated, capable of handling routine flight patterns, and great at making the journey smoother. But who’s in the cockpit? The pilot. Handing a complex project to an AI without a human in charge is like giving a toddler a chainsaw and telling them to go build a treehouse. You might get a result, but it’s going to be a disaster.

You’re the guardrail. AI can’t check its own work. It can generate code that looks right, but you, the developer, are the one who has to verify it, test it, and ensure it doesn’t create a security nightmare. You’re the one with the critical thinking to see that the code is technically correct but completely wrong for the project’s long-term health.
You’re the shepherd. AI needs to be guided. It doesn’t understand context, business goals, or the nuanced “why” behind a project. Your job is to translate complex human intent into clear instructions for the AI, then take its output and shape it into a cohesive solution.
You’re the student. This is where the real value lies. AI is the greatest tutor you will ever have. Instead of being replaced by it, a smart junior developer will use it to accelerate their learning. Stuck on a complex problem? Ask the AI for a starting point. Unsure about a new framework? Have the AI walk you through a simple example.

Don’t let anyone tell you AI is the end of the line for new talent. It’s the beginning of a new chapter where human creativity and critical thinking become even more valuable. The developers who will thrive in the future aren’t the ones who can just type code; they’re the ones who can master the most powerful tool on the planet and use it to build something incredible.

So the next time you hear someone say a robot is coming for your job, just smile. You know the truth. You’re not being replaced; you’re being handed a superpower.

The C# Mistake You're Probably Making with Memory

Tue, 19 Aug 2025 13:22:21 +0100

C#’s Garbage Collector is a powerful tool for automatic memory management, but it doesn’t solve every resource management problem. While it efficiently cleans up unreferenced managed objects, there are specific resources that require a more deterministic approach to ensure they are released promptly. This is where the using statement comes in.

The Role of the Garbage Collector

The Garbage Collector (GC) in C# is designed to reclaim memory from managed objects that are no longer being used by the application. It works in the background, periodically identifying and freeing up memory, which prevents memory leaks and simplifies development. . However, the GC’s timing is nondeterministic—you can’t predict exactly when it will run.

This nondeterministic nature is perfectly fine for memory, but it’s a problem for unmanaged resources like file handles, database connections, network sockets, or graphics handles. If these resources aren’t released as soon as they’re no longer needed, they can remain locked or open, causing issues like file access errors or resource exhaustion.

The Power of the `using` Statement

The using statement provides a simple and reliable way to ensure that these unmanaged resources are released promptly. It’s a syntactic shortcut for a try...finally block that automatically calls the Dispose() method on an object when it goes out of scope.

An object can be used in a using statement only if it implements the IDisposable interface. This interface contains a single method, Dispose(), which is responsible for cleaning up the unmanaged resources held by the object.

Here’s a quick example:

// Without a using statement
FileStream fs = null;
try
{
fs = new FileStream("example.txt", FileMode.Open);
// Do something with the file
}
finally
{
if (fs != null)
{
fs.Dispose();
}
}
// With a using statement
using (var fs = new FileStream("example.txt", FileMode.Open))
{
// Do something with the file
} // The Dispose() method is automatically called here

As you can see, the using statement makes the code cleaner and less prone to errors. It guarantees that the Dispose() method is called even if an exception occurs within the block, ensuring resources are always released.

Best Practices for Resource Management

Incorporating the using statement into your daily coding habits is a simple but critical best practice. It ensures that your applications are robust, efficient, and well-behaved, especially when dealing with external resources.

By using it, you’re not fighting against the Garbage Collector but instead working with it. The GC handles the memory, and you take deterministic control of valuable unmanaged resources. This combined approach leads to more stable and performant C# applications. So, next time you’re working with a file, a database connection, or any other IDisposable object, remember to use a using statement. It’s a small change that makes a big difference.

Don't Buffer, Stream! How IAsyncEnumerable Solves API Performance Issues

Mon, 18 Aug 2025 11:34:34 +0100

Building APIs that handle large datasets can be a challenge. A common approach is to collect all the data into a list, convert it to JSON, and then send it all at once. But what happens when that dataset is massive? Your API might freeze up while it’s building the response, and you could end up with a huge memory footprint. Fortunately, ASP.NET Core provides a great solution for this problem: IAsyncEnumerable<T>.

What is `IAsyncEnumerable<T>`?

Introduced in C# 8.0, IAsyncEnumerable<T> allows you to iterate through data asynchronously. This is perfect for streaming scenarios where you need to process or return data in chunks, rather than all at once. When you use it in an ASP.NET Core API endpoint, the framework will serialise and send data to the client as it becomes available. This is different from the traditional approach, where the entire collection must be ready before the response can be sent.

Why Use `IAsyncEnumerable<T>`?

There are two main benefits to using IAsyncEnumerable<T> for your API endpoints:

1. Improved Performance: You no longer have to wait for the entire dataset to be built in memory. As soon as the first item is ready, it can be sent to the client. This can significantly reduce the time to first byte and make your API feel more responsive, especially for large queries.

2. Reduced Memory Usage: Instead of holding the entire collection in memory, your application only needs to hold a small number of items at a time. This is a game-changer for handling large datasets, as it can prevent your application from consuming excessive memory and potentially crashing.

How to Implement It

Implementing IAsyncEnumerable<T> in an ASP.NET Core API is straightforward. Here’s a simple example of a controller method that streams a large number of items.

[ApiController]
[Route("[controller]")]
public class ProductsController : ControllerBase
{
// Simulates fetching a large number of products from a database
 private async IAsyncEnumerable<Product> GetProductsFromDatabase()
{
for (int i = 1; i <= 10000; i++)
{
await Task.Delay(50); // Simulate an async operation like a database call
 yield return new Product { Id = i, Name = $"Product {i}" };
}
}

 [HttpGet("stream")]
public IAsyncEnumerable<Product> GetStreamedProducts()
{
return GetProductsFromDatabase();
}
}
public class Product
{
public int Id { get; set; }
public string Name { get; set; }
}

In this example, the GetProductsFromDatabase method uses the yield return keyword to return items one by one. The IAsyncEnumerable<Product> return type tells the ASP.NET Core runtime to stream the data as it’s being generated.

Important Considerations

While IAsyncEnumerable<T> is a powerful tool, it’s not a silver bullet. Keep these things in mind:

Client Compatibility: The client calling the API must be able to handle a streamed response. Most modern web clients and frameworks support this out of the box, but older or custom clients might have issues.
Error Handling: If an exception occurs partway through streaming, the client will receive an incomplete response. You need to handle errors gracefully and ensure the client can deal with a connection that might be abruptly closed.
HTTP Protocol: Under the hood, this works by leveraging the Transfer-Encoding: chunked header in HTTP. This is standard for HTTP/1.1 and later, but it’s good to be aware of how the data is being sent.

Conclusion

For backend developers working with large datasets, IAsyncEnumerable<T> is a fantastic tool to have in your arsenal. It provides a simple and effective way to build more responsive and memory-efficient APIs. By streaming data instead of buffering it all in memory, you can significantly improve the user experience and the overall health of your application.

Most Unit Tests Are a Waste of Time, but You Need to Write Them Anyway

Sat, 26 Jul 2025 20:03:53 +0100

Yes, I’m saying it, most unit tests feel like a waste of time.

You write loads of them. They break when you refactor. They rarely catch real bugs. When you change implementations, you delete the tests. And when your build fails, it’s usually because a mocked method didn’t behave as expected — not because your code actually broke.

So why do we keep writing them?

Because while most unit tests are a waste of time, some aren’t — and knowing the difference is what separates a codebase held together by guesswork from one that’s confidently shippable.

Why Most Unit Tests Feel Pointless

In a typical C# MVC application, unit testing often devolves into testing the mocks, not the code. Consider:

Example:

var mockService = new Mock<IUserService>();
mockService.Setup(x => x.GetUser(1)).Returns(new User { Id = 1 });
var controller = new UserController(mockService.Object);
var result = controller.Get(1);

What are we really testing here? Not the routing. Not the service logic. Just that a mock returns a hardcoded result we told it to. If this breaks, the app doesn’t necessarily break. If this passes, it doesn’t mean the app works.

Then there are tests for trivial logic:

[Test]
public void Add_ShouldReturnSum()
{
var math = new MathHelper();
var result = math.Add(2, 2);
Assert.AreEqual(4, result);
}

Congratulations, you proved addition works. Now imagine 300 of these tests — offering zero protection against real bugs.

So yes, most of these are a waste of your time.

But Here’s Why You Still Need Them

Despite all that — you need to write tests anyway.

Not because they guarantee zero bugs (they don’t). But because:

Tests Define Behavior

Well-written unit tests act as executable documentation. They describe what the system is supposed to do, especially when future devs (or future you) forget the intent.

Tests Enable Refactoring

You can’t safely refactor without some safety net. If you’re pulling apart a C# service or controller, tests that cover logic (not mocks) help you know what broke immediately.

Tests Catch Edge Cases You’ll Forget

You might test the happy path manually. But do you check null inputs every time? Timezone logic? Unauthorised users? Unit tests can force you to handle those cases.

What to Write Instead of Meaningless Tests

Since we’ve established that not all tests are worth writing, here’s what is:

1. Test Real Business Logic

Skip trivial logic. Instead, focus on functions that make decisions, mutate data, or contain rules.

[Test]
public void PromoteUser_ShouldSetRoleToAdmin()
{
var user = new User("basic");
var service = new UserService();
service.Promote(user);
Assert.AreEqual("Admin", user.Role);
}

This is logic that could break. This test is worth writing.

2. Use In-Memory Dependencies Instead of Mocks

Whenever possible, avoid mocking and use real implementations or in-memory versions.

var options = new DbContextOptionsBuilder<AppDbContext>()
.UseInMemoryDatabase("TestDb")
.Options;
using var context = new AppDbContext(options);
context.Users.Add(new User { Id = 1, Name = "Alice" });
context.SaveChanges();
var service = new UserService(context);
var user = service.GetUser(1);
Assert.AreEqual("Alice", user.Name);

This approach:

Covers real database logic (e.g., query filters, relationships)
Doesn’t break when you rename a method
Actually catches bugs

3. Favor Integration Tests for Controllers

In C# MVC apps, controller unit tests with mocked services rarely give you confidence. Instead, use integration tests that spin up the full pipeline:

[Test]
public async Task GetUser_ReturnsExpectedUser()
{
var client = _factory.CreateClient();
var response = await client.GetAsync("/api/user/1");
response.EnsureSuccessStatusCode();
var body = await response.Content.ReadAsStringAsync();
Assert.IsTrue(body.Contains("Alice"));
}

This tells you:

Routing works
The controller is wired correctly
The real service/database returned something valid

So What’s the Right Balance?

Here’s a rule of thumb I’ve come to rely on:

If a test would still pass after you’ve broken the app, delete it.

The tests worth keeping:

Validate decisions or calculations
Catch regressions during refactors
Fail only when something meaningful breaks

Final Thoughts: Write Less, Test Smarter

You don’t need 100% test coverage. You need meaningful coverage.

So yes — most unit tests are a waste of time when they’re written to check boxes or appease CI gates. But tests that clarify logic, guard complex behavior, and give you confidence to ship? Those are worth every second.

Write tests like your future self depends on them — because they do.

Snap Unsnapped: Why Ubuntu's Packaging Isn't the Universal Dream You Were Promised

Tue, 22 Jul 2025 21:38:31 +0100

Ubuntu’s Snap packaging system was introduced with the promise of universal Linux applications, easy updates, and robust security through confinement. While these goals are admirable, the reality of Snap for many desktop users has been a source of frustration, leading to a growing sentiment that “Ubuntu Snap sucks.” This isn’t just a matter of preference; it’s rooted in several fundamental design choices that hobble user experience, resource efficiency, and even security.

The Walled Garden: Isolation to a Fault

One of the most significant criticisms leveled against Snap is its “walled garden” approach. While touted as a security feature, the strict confinement of Snap applications often goes too far, isolating them from the very operating system features that make Linux a joy to use.

Imagine trying to work with a program that can’t easily interact with the rest of your system. This is often the case with Snaps. Simple actions like drag-and-dropping files from your file manager into a Snap application can be a frustrating exercise in futility. The application, confined within its “garden,” often lacks the necessary permissions to directly access files outside its designated sandboxed directories. Similarly, opening files from arbitrary locations on your system, or even saving to them, can become a convoluted process, breaking the seamless workflow expected of a modern desktop environment. This isolation, while aiming for security, inadvertently creates an inefficient and disjointed user experience.

Resource Hog: High RAM and Disk Space Usage

Another common complaint revolves around Snap’s often-inflated resource consumption. Snaps bundle all their dependencies, even those already present on your system through traditional package managers. This “self-contained” nature, while simplifying deployment for developers, leads to significant redundancy for users.

High Disk Space Usage: Each Snap application carries its own set of libraries and dependencies. If you have multiple Snaps that rely on the same underlying libraries (and many do, especially core GNOME components), those libraries are duplicated for each Snap. This quickly leads to a substantial increase in disk space usage compared to traditionally packaged applications that leverage system-wide shared libraries. Furthermore, Snap retains old versions of applications for rollback purposes, further contributing to disk bloat if not actively managed.
High RAM Usage: The duplicated libraries aren’t just a disk space concern; they can also impact RAM. When multiple Snap applications are running, they might each be loading their own copies of shared libraries into memory, rather than sharing a single instance. This can lead to a noticeable increase in RAM consumption, particularly on systems with limited memory, making the overall system feel sluggish.

Outdated and Insecure: Version Disparity and Security Risks

While Snaps are designed to offer quick updates, the reality can be quite different. A concerning issue for many users is the version disparity between Snap packages and system packages. It’s not uncommon for the Snap version of a popular application to lag several versions behind what’s available through a distribution’s traditional package repositories (like APT on Ubuntu).

This lag can be problematic for several reasons:

Missing Features and Bug Fixes: Users might miss out on the latest features, performance improvements, and crucial bug fixes present in newer versions.
Potential Security Vectors: Perhaps most critically, outdated software versions are often unpatched versions. When a Snap lags behind, it might not include recent security patches for vulnerabilities discovered in its bundled dependencies. This transforms the “security through confinement” promise into a potential security liability, as an unpatched vulnerability within a Snap could still be exploited, even if the rest of your system is up to date.

The Ecosystem Conundrum: Canonical’s Control

Beyond the technical issues, the very nature of Snap as a Canonical-controlled ecosystem raises concerns for some in the open-source community. The Snap Store, the centralized repository for Snap applications, is proprietary. This level of control, while offering certain benefits in terms of curation and distribution for Canonical, goes against the decentralized and open philosophy that underpins much of the Linux world. This can lead to a feeling of being locked into a single vendor’s ecosystem, similar to the “walled gardens” seen in proprietary operating systems.

Conclusion: A Promising Idea with Implementation Flaws

Ubuntu’s Snap technology, with its ambitions for universal packaging and enhanced security, had a strong vision. However, its current implementation on the desktop has introduced a range of issues that actively detract from the user experience. The restrictive confinement, leading to difficulties with fundamental desktop interactions like drag-and-drop, coupled with its resource-intensive nature and the often-outdated software versions, paints a picture of a system that, for many, “sucks.”

While development continues and improvements are undoubtedly being made, the fundamental trade-offs in Snap’s design remain a significant hurdle for widespread acceptance and a source of ongoing frustration for a substantial portion of the Ubuntu user base. For those seeking a truly integrated, efficient, and open Linux desktop experience, the current state of Snap leaves much to be desired.

Why Leetcode Style Interview Tests Are Bullshit

Mon, 09 Jun 2025 09:24:04 +0100

Everybody has heard of the leetcode style interview tests, and given their prominence in the tech news recently, you won’t be surprised to find out that this is another story highlighting their inherent flaws.

Recently, after a remote interview on teams, I was given a set of 3 different leetcode style interview test questions. I was told to take “no more than 3 hours total” and to “write it using typescrypt”.

39 minutes later, I had completed and submitted all 3 tests, and all 3 tests pass all test cases. So now you ask, what’s the problem?

You Clearly Cheated?! (I didn’t)

I was immediately accused of cheating by the VP of Engineering, even though the site has monitoring tools to detect if i was cheating (which if i WAS cheating, which i wasn’t, it wouldn’t have detected anything). The site claims it would detect if I tabbed away, or if I had copied any text out of the test, or pasted anything into the test, I had my doubts, but I didnt need to cheat so why would I.

Apparently, it is impossible, with 20+ years of experience being a professional software developer, to do what their VP of Engineering says should have taken 3 hours, in 39 minutes.

They could provide no proof, the site and its “monitoring tools” detected no selecting of any of the text, no copying of the text, no pasting of anything at all, didn’t detect me tabbing away from the browser. The accusation was entirely down to, others who have taken it, have taken a lot longer, and the VP himself, took a lot longer.

If you and your company put so much weight on these tests, you should:

Be good at them
Accept that there are some people, for whom it is possible to be better than you at them
Don’t accuse people of cheating if you cannot show any evidence that they cheated

In the end, the interviewer (the VP of Engineering) would not back down, they would not accept that I didn’t use an LLM (such as copilot). I offered to do another test with them watching and also offered to show them that IF I was to be cheating, that it would not have taken me 39 minutes, they declined. After the call, I did go back and re-do the same 3 tests with the assistance of gemini, not copilot, because i wanted to see if it was possible to cheat with a tool that more people have access to, it took 4 minutes to complete all 3 tests.

For anybody who is interested in trying the tests they gave me for themselves, these are the equivalent tests on leetcode itself (the site they had me use was a different site that requires a paid subscription by an employer):

How quickly can you get through these in typescript, or any other language, with and without cheating?

The Darker Side of Tech Layoffs (it's darker than it seems)

Wed, 14 May 2025 12:56:37 +0100

The headlines have been stark: tech giant after tech giant announcing significant layoffs. While the immediate impact on those made redundant is undeniable and deeply upsetting, the fallout from these decisions extends far beyond those who receive the dreaded news. The industry wide repercussions are creating a climate of increased pressure, stifled career movement, and potentially lower earning potential for a vast number of tech professionals.

Let’s unpack the less visible, yet equally significant, ways tech redundancies are impacting everyone else.

The Weight of More with Less: The Burden on Remaining Employees

For those who remain after a round of layoffs, a sense of relief can quickly morph into a feeling of overwhelming pressure. Companies, often driven by a desire to maintain output with a leaner workforce, expect the same amount of work or even more to be accomplished by fewer people, which can translate to:

Increased workload: Remaining employees are often expected to absorb the responsibilities of their former colleagues, leading to longer hours and a heavier burden.
Reduced resources: Teams may find themselves with fewer resources, tools, or support staff, making it harder to execute projects efficiently.
Heightened stress and anxiety: The fear of future layoffs, coupled with the increased workload, creates a climate of uncertainty and anxiety, impacting morale and well-being.
Skill gaps and the pressure to upskill rapidly: Individuals may be asked to take on tasks outside their core expertise, leading to pressure to learn new skills quickly without adequate support or training.

This environment inevitably fuels burnout. The tech industry was already grappling with high rates of stress and exhaustion. Asking fewer people to do the work of many is a surefire way to exacerbate this existing crisis.

The Golden Handcuffs Tighten: The Frustration of Those Seeking New Opportunities

For tech professionals actively looking to leave their current roles for better opportunities, the wave of redundancies presents a frustrating Catch-22. While there might be new roles opening due to the layoffs, the dynamics of the job market have shifted:

Extended Notice Periods: Individuals in stable employment are often bound by notice periods, which can range from weeks to months. Meanwhile, those made redundant are immediately available, giving them a significant advantage in a competitive job market.
Missed Opportunities: By the time someone with a notice period is free to start, the roles they were interested in might already be filled by candidates who were made redundant and could start immediately.
Feeling Trapped: This situation can leave those wanting to move feeling stuck and resentful, further contributing to dissatisfaction and potential burnout in their current roles.

The irony is palpable: individuals seeking growth and new challenges are penalised for their current employment stability in a market flooded with immediately available talent.

The Downward Pressure on Salaries: A Threat to Earning Potential

Perhaps one of the most concerning long-term effects of widespread redundancies is the potential downward pressure on salaries across the tech industry. This happens because:

Increased Supply of Talent: A large pool of skilled tech professionals suddenly enters the job market.
Willingness to Accept Lower Pay: Some of those made redundant may be in a position where they need to secure employment quickly, making them more willing to accept salaries lower than their previous earnings or the prevailing market rate.
Employer Leverage: Companies looking to hire can leverage this increased supply and the willingness of some candidates to accept less, potentially driving down salary offers for everyone.

This erosion of salary expectations can have a significant impact on the financial wellbeing of all tech workers, not just those who were laid off. It can lead to:

Reduced earning potential: Even those who remain employed or find new roles may find it harder to negotiate competitive salaries.
Decreased morale and motivation: Feeling undervalued due to stagnant or declining salary prospects can further contribute to burnout and dissatisfaction.
A less attractive industry: In the long run, lower salaries could make the tech industry less attractive to new talent, potentially hindering innovation and growth.

The Vicious Cycle: Redundancies Fuelling More Burnout

The interconnectedness of these factors creates a dangerous cycle that can significantly worsen the existing burnout crisis in the tech industry. Increased workloads, stifled career movement, and the fear of salary stagnation or decline all contribute to a more stressful and less rewarding work environment.

When people feel overworked, undervalued, and trapped, their motivation plummets, and their risk of burnout skyrockets. This can lead to decreased productivity, higher turnover in the long run (even among those who weren’t initially laid off), and a less vibrant and innovative tech ecosystem.

Looking Ahead: A Call for Empathy and Sustainable Practices

While companies may see redundancies as a necessary measure in challenging economic times, it’s crucial to recognise the far-reaching consequences. Ignoring the impact on remaining employees and the broader talent pool is a short-sighted approach that can have detrimental long-term effects.

Moving forward, a greater emphasis on sustainable growth, fair treatment of all employees (both departing and remaining), and a recognition of the human cost of these decisions is essential. Only then can the tech industry hope to mitigate the negative ripple effects of redundancies and foster a healthier, more resilient, and ultimately more productive environment for everyone.

AI is Making Developers Lazy: RIP Core Coding Skills

Wed, 07 May 2025 12:53:44 +0100

The hum of the AI co-pilot has become a familiar soundtrack in the world of software development. These intelligent tools, promising increased efficiency and code generation prowess, have been embraced with open arms by many. But what happens when this reliance morphs into over-dependence? What are the potential pitfalls of blindly trusting algorithms we don’t fully comprehend, especially when they occasionally – or even frequently – get it wrong? And perhaps most worryingly, what becomes of the core skills that define a truly capable software developer?

The allure is undeniable. Imagine effortlessly generating boilerplate code, instantly debugging complex errors, or even having entire modules sketched out for you. AI tools offer the promise of freeing up developers from repetitive tasks, allowing them to focus on higher-level problem-solving and innovation. However, this convenience comes with a potential Faustian bargain.

The Black Box Problem: Trusting What We Don’t Understand

Many of the sophisticated AI models powering these tools operate as “black boxes.” We feed them data and receive output, but the intricate web of algorithms and decision-making processes within remains opaque. This lack of transparency can be problematic, especially when the AI generates incorrect or suboptimal code.

If developers don’t possess a strong foundational understanding of the underlying principles, how can they effectively evaluate the AI’s suggestions? How can they discern a clever solution from a flawed one? The danger lies in blindly accepting AI-generated code without critical review, potentially introducing bugs, security vulnerabilities, and inefficient designs into the codebase.

The Erosion of Core Skills: A Muscle Unused Withers

Software development is a craft built upon a foundation of problem-solving, logical reasoning, algorithmic thinking, and a deep understanding of programming paradigms. These core skills are honed through years of practice, experimentation, and the occasional struggle.

When developers become overly reliant on AI to generate code and solve problems, these fundamental skills can atrophy. Imagine a musician who always relies on auto-tune; their natural pitch and vocal control will likely diminish over time. Similarly, a developer who constantly leans on AI might lose the ability to:

Think algorithmically: Understanding how to break down complex problems into logical steps becomes less crucial if an AI can seemingly generate the solution.
Debug effectively: If developers haven’t developed the intuition for identifying and tracing errors themselves, they may struggle when the AI’s suggestions are unhelpful or misleading.
Write clean and efficient code: Over-reliance on AI might lead to a neglect of coding best practices, resulting in bloated, difficult-to-maintain codebases.
Understand system architecture: A superficial understanding of how different components interact might suffice if AI is handling the intricate details.
Adapt to new technologies: The rapid evolution of the tech landscape demands continuous learning and adaptation. Developers who haven’t cultivated strong learning skills might find themselves struggling when AI tools don’t yet support the latest advancements.

The “Wrong” Factor: AI’s Inherent Imperfection

It’s crucial to remember that current AI tools are not infallible. They learn from data, and if that data contains biases or errors, the AI will likely perpetuate them. Furthermore, AI models can sometimes generate syntactically correct but semantically flawed code, or suggest solutions that are technically feasible but architecturally unsound.

If developers lack the critical thinking skills to identify these inaccuracies, they risk building flawed systems based on faulty AI outputs. This can lead to costly rework, security breaches, and ultimately, a decrease in the quality and reliability of software.

Finding the Balance: Augmentation, Not Replacement

The future of software development likely involves a symbiotic relationship between humans and AI. These tools have the potential to be powerful augmentations to our abilities, freeing us from tedious tasks and offering new perspectives. However, the key lies in maintaining a strong foundation of core development skills.

Developers should approach AI tools with a healthy dose of skepticism and a commitment to understanding the “why” behind the “what.” We must remain active participants in the development process, using AI as a powerful assistant rather than a complete replacement for our own expertise.

Moving Forward: Cultivating Critical Thinking in the Age of AI

To avoid the pitfalls of over-reliance, the software development community needs to prioritize:

Emphasis on fundamental skills: Educational institutions and training programs should continue to stress the importance of core programming principles and problem-solving techniques.
Promoting critical evaluation: Developers should be encouraged to critically analyze AI-generated code and understand its implications.
Continuous learning: Staying abreast of both AI advancements and fundamental development practices is crucial.
Transparency and explainability: The development of more transparent and explainable AI models will be vital in fostering trust and understanding.

The rise of AI in software development presents both exciting opportunities and potential dangers. By embracing these tools responsibly and ensuring that our core skills remain sharp, we can harness the power of AI to build better software without sacrificing the expertise and ingenuity that defines us as developers. The algorithmic crutch might offer temporary relief, but true mastery lies in our own understanding and ability to craft elegant and robust solutions.

The Optimisation Lie: Why Your 'Optimised' Code Might Still Be Slow

Thu, 01 May 2025 09:57:02 +0100

We’ve all been there. You’ve tweaked a loop, maybe used a more efficient LINQ method, and patted yourself on the back for “optimising” your C# code. The profiler might even show a slight improvement. But then, the application still feels… sluggish. That’s because the initial steps in optimisation can be deceptively easy, leading to what we’ll call The Optimisation Lie, the belief that a few superficial changes equate to truly well-optimised software.

The truth is, while applying basic optimisations in C# is often straightforward, achieving significant and sustainable performance gains requires a much deeper understanding and a more strategic approach.

The Siren Song of Simple C# Optimisations

C# offers many seemingly easy ways to improve performance at a glance:

String Concatenation

Switching from repeated + operations to StringBuilder.

// The "easy" fix
string message = "";
for (int i = 0; i < 1000; i++)
{
message += i.ToString(); // Inefficient
}
// The slightly better approach
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++)
{
sb.Append(i.ToString());
}
message = sb.ToString();

This is a common and valid initial optimisation, but it might not be the biggest bottleneck in your application.

LINQ Efficiency

Choosing the “right” LINQ method.

// Potentially less efficient
var expensiveResult = myList.Where(x => x > 10).Select(y => y * 2).ToList();
// Potentially more efficient (depending on the scenario)
var betterResult = (from x in myList where x > 10 select x * 2).ToList();

While LINQ can be powerful, understanding its underlying execution and potential overhead is crucial. Simply switching methods without profiling might not yield significant gains.

Basic Caching

Implementing a simple Dictionary<TKey, TValue> for frequently accessed data.

private static Dictionary<int, User> _userCache = new Dictionary<int, User>();
public User GetUser(int id)
{
if (_userCache.ContainsKey(id))
{
return _userCache[id]; // Easy cache hit
 }
User user = FetchUserFromDatabase(id);
_userCache[id] = user;
return user;
}

Basic caching is easy to implement, but managing cache invalidation, concurrency, and memory usage effectively is far more complex.

These “easy wins” can provide a sense of accomplishment, but they often scratch the surface of underlying performance issues.

The Treacherous Path to Genuine C# Optimisation

Optimising C# code well requires a more holistic and data-driven approach:

Identifying the Real Bottleneck with Profiling

Guesswork is the enemy of good optimisation. Tools like the Visual Studio Profiler, PerfView, or JetBrains dotTrace are essential to pinpoint the actual performance bottlenecks in your C# application. Is it database access, network I/O, garbage collection, or a specific algorithm?

// Example: Using Stopwatch for basic timing
var stopwatch = Stopwatch.StartNew();
// Code block to profile
stopwatch.Stop();
Console.WriteLine($"Elapsed Time: {stopwatch.ElapsedMilliseconds} ms");

Real profiling tools provide much more granular insights.

Understanding Asynchronous Operations (async/await)

In I/O-bound operations (like network requests or file access), blocking the main thread can lead to significant performance issues and UI freezes. Mastering async and await in C# is crucial for responsiveness.

public async Task<string> DownloadDataAsync(string url)
{
using (var httpClient = new HttpClient())
{
var response = await httpClient.GetAsync(url); // Non-blocking
 response.EnsureSuccessStatusCode();
return await response.Content.ReadAsStringAsync(); // Non-blocking
 }
}

Simply using async without understanding its implications (e.g., thread context switching) might not yield optimal results.

Efficient Data Structures and Algorithms

Choosing the right data structure (e.g., HashSet for fast lookups, List for ordered collections) and algorithms (e.g., avoiding nested loops where a more efficient approach exists) can have a massive impact on performance, especially with large datasets.

// Inefficient search in a List
bool containsItemSlow = myList.Contains(someItem); // O(n)

// Efficient search in a HashSet
HashSet<string> mySet = new HashSet<string>(myList);
bool containsItemFast = mySet.Contains(someItem); // O(1) on average

Memory Management and Garbage Collection

Understanding how the .NET garbage collector works and minimising unnecessary object allocations can significantly improve performance and reduce pauses. Techniques like object pooling or using struct for small, value-type data can be beneficial in specific scenarios.

// Example of potential excessive object creation
for (int i = 0; i < 1000; i++)
{
string temp = "prefix-" + i.ToString(); // Creates a new string in each iteration
 // ... use temp ...
}

Database Optimisation

Often, the biggest performance bottlenecks lie in database interactions. This involves writing efficient SQL queries, using appropriate indexing, and understanding your database’s execution plan. While not strictly C# code, it’s a critical part of many C# applications.

Concurrency and Parallelism (Task Parallel Library - TPL)

Leveraging multi-core processors with the TPL (Task.Run, Parallel.For/ForEach) can dramatically improve performance for CPU-bound tasks. However, managing shared state, avoiding race conditions, and understanding the overhead of task creation are essential for effective parallelism.

// Parallel processing using Parallel.ForEach
Parallel.ForEach(dataList, item =>
{
// Perform CPU-bound operation on each item
 ProcessItem(item);
});

Poorly implemented parallelism can lead to performance degradation and hard-to-debug errors.

Context and Measurement are King

Optimisation efforts must be driven by clear performance goals and rigorous measurement. What are the acceptable response times? What are the resource constraints? Without benchmarking and profiling before and after optimisations, you’re flying blind. Tools like BenchmarkDotNet are invaluable for precise performance measurements in C#.

[MemoryDiagnoser]
public class StringVsStringBuilder
{
private const int N = 1000;

 [Benchmark]
public string ConcatStrings()
{
string message = "";
for (int i = 0; i < N; i++)
{
message += i.ToString();
}
return message;
}

 [Benchmark]
public string StringBuilderAppend()
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < N; i++)
{
sb.Append(i.ToString());
}
return sb.ToString();
}
}

The Art of True C# Optimisation:

Effective C# optimisation is a continuous process of analysis, strategic implementation, and meticulous measurement. It’s about understanding the underlying mechanisms of the .NET runtime, choosing the right tools and techniques for the specific problem, and always validating your assumptions with data.

Don’t fall for the optimisation lie. While those initial quick fixes might offer a small boost, achieving truly performant and scalable C# applications requires a deeper dive and a commitment to data-driven decision-making. So, equip yourself with profiling tools, understand the intricacies of asynchronous programming and memory management, and always measure the impact of your changes. That’s the path to unlocking the true potential of your C# code.

The Dirty Secret of Clean Code: When Breaking Programming Principles Makes You a Better Developer

Tue, 08 Apr 2025 13:02:53 +0100

If you’ve been in software development for more than five minutes, you’ve probably had these acronyms beaten into your head:

SOLID: that five-headed monster of principles that’s supposed to make your code amazing.

DRY: because apparently typing the same logic twice will summon demons or something.

Don’t get me wrong, these principles exist for good reasons! They’ve saved countless developers from nightmare codebases. But here’s the kicker: they’re guidelines, not commandments handed down from the mountain.

When It’s Totally Fine to “Break the Rules”

Look, we’ve all been there. You’re coding away, trying to follow all those fancy principles they taught you, and suddenly you find yourself twisting your code into pretzels just to satisfy some abstract concept like “Single Responsibility” or “Don’t Repeat Yourself.”

And you know what? Sometimes that’s completely unnecessary.

When You Need to Ship Yesterday

Let’s be real: sometimes you just need to get that feature out the door. If you’re staring at a tight deadline and your code works but isn’t perfectly SOLID, guess what? That’s life. Ship it. Fix it later if it causes problems.

When You’re Just Figuring Stuff Out

Early in a project, you barely know what the code needs to do, let alone how to structure it perfectly. Trying to make everything SOLID before you even understand the problem is like buying wedding rings on a first date.

When Perfect Code Means Perfectly Unreadable

I’ve seen codebases where developers followed DRY so religiously that understanding what any function actually did required tracing through fifteen layers of abstraction. Sometimes a little repetition makes code way easier to understand.

When Performance Actually Matters

“But what about the performance hit from all those tiny functions?” If you’re writing code for a toaster with 2KB of RAM, or handling millions of operations per second, sometimes breaking SRP is the right call.

The Real-World Example

Last month, I was working on this dashboard feature. According to SOLID, I should’ve split this one class into like, five different classes with their own interfaces. But you know what? It was one specific feature that wasn’t going to be reused elsewhere. Breaking it apart would’ve just scattered related code for no real benefit.

So I kept it as one chunky class that did several things. Scandalous, I know! But guess what? It works great, everyone understands it, and the world didn’t end.

Finding Your Balance

The secret sauce of being a good developer isn’t memorising rules – it’s knowing when to apply them and when to say “nah, not this time.”

Ask yourself:

Will this abstraction actually help anyone, or am I just doing it to feel smart?
Is this code going to change often, or is it pretty stable?
Will splitting this make it easier or harder for the next person to understand?
Am I solving real problems or imaginary future ones?

The Bottom Line

Programming principles are like those pirate code guidelines from Pirates of the Caribbean – they’re more like suggestions than actual rules. The end goal is working, maintainable software that solves real problems – not code that wins theoretical purity contests.

Next time you find yourself going through backflips to satisfy some principle, ask yourself if it’s actually making your code better or just making you feel better.

What coding “rules” have you broken lately? Drop a comment – I promise not to report you to the code police!

AI Is Smart Because You Are Stupid

Sun, 30 Mar 2025 21:55:08 +0100

Artificial Intelligence is often perceived as a technological marvel, a near-mystical force that can predict, automate, and generate at an astonishing rate. However, this perception isn’t necessarily because AI is truly “intelligent” in the way humans are. Rather, AI appears good because humans, by comparison, are inconsistent, distracted, and prone to errors. The brilliance of AI is not in its innate intelligence, but in how it exploits human shortcomings.

The Illusion of Intelligence

AI, at its core, is a set of algorithms trained on vast datasets to recognise patterns, generate responses, and optimise tasks based on statistical probabilities. It does not “think,” nor does it possess creativity or consciousness. Yet, when AI completes tasks efficiently - be it answering questions, summarising documents, or even generating art - it seems astonishingly capable. This is because it operates without fatigue, bias (at least in theory), or hesitation, whereas humans are plagued by these very limitations.

Think about it: an AI can generate a well-structured essay in seconds, but how often do humans struggle with writer’s block? AI can recognise patterns in financial markets faster than any expert, but how often do humans make emotional investment decisions? The disparity isn’t necessarily because AI is “smart”; it’s because humans, in comparison, are imprecise and inefficient.

The Dependence Problem

Because AI highlights human shortcomings, many people have come to rely on it for tasks that they could otherwise accomplish themselves. Spellcheck and grammar tools improve writing that should be polished by the writer. AI-assisted coding corrects errors that developers might have caught with proper debugging. Recommendation algorithms dictate consumer choices, reducing the need for personal decision-making. The issue isn’t that AI is better - it’s that people have lowered their standards and delegated tasks they no longer want to engage with fully.

A Reflection of Human Limitations

AI’s seeming intelligence is, in many ways, a mirror that reflects our own intellectual laziness. It is easy to be impressed by a chatbot’s ability to hold a coherent conversation - until you realise that much of human conversation is just as formulaic and predictable. We praise AI for generating stunning images, but we fail to acknowledge that creativity itself is often just an assembly of existing concepts. AI highlights the shortcuts that humans wish they could take but lack the processing speed to execute.

The Challenge for the Future

Instead of being in awe of AI’s capabilities, we should ask ourselves what this technology reveals about us. Are we allowing AI to replace critical thinking? Are we using it as a tool for enhancement or as a crutch for laziness? The danger isn’t that AI is becoming too intelligent - it’s that humans are becoming too complacent.

AI seems good because it compensates for our inefficiencies. The real question is: will we use it to elevate ourselves, or will we allow it to replace what makes us uniquely human?

.NET Aspire - Microsoft's Attempt at Infrastructure as Code

Fri, 28 Mar 2025 10:21:43 +0000

.NET Aspire is a new set of tools, templates, and packages from Microsoft designed to make building cloud-native applications with .NET easier and more efficient. It helps developers create applications that are resilient, observable, and ready for production.

What is .NET Aspire?

Traditionally, developers wrote code while operations teams managed the infrastructure it ran on. This separation could lead to challenges in ensuring that applications and their environments worked well together. .NET Aspire aims to bridge this gap by allowing developers to define both their applications and the necessary infrastructure in a unified way.

How Does .NET Aspire Work?

In a .NET Aspire project, you can define various components like databases, caches, and APIs, and specify how they connect. This is done in a central place called the “app host,” which acts as an orchestrator for your application. Here’s an example:

var builder = DistributedApplication.CreateBuilder(args);
var postgres = builder.AddPostgres("postgres");
var catalogDb = postgres.AddDatabase("catalogdb");
var basketCache = builder.AddRedis("basketcache");
var productsApi = builder.AddProject<Projects.Aspire_Products_Api>("productsapi")
.WithReference(catalogDb);
var basketApi = builder.AddProject<Projects.Aspire_Basket_Api>("basketapi")
.WithReference(basketCache);
builder.AddProject<Projects.Aspire_Frontend>("frontend")
.WithReference(basketApi)
.WithReference(productsApi);

In this code, a PostgreSQL database and a Redis cache are set up. These are then linked to the appropriate backend APIs for products and baskets. Finally, the frontend application is connected to these backend services. This setup ensures that each part of the application knows how to communicate with the others without needing to know specific URLs or connection details.

What Does This Mean for Infrastructure as Code (IaC)?

Infrastructure as Code (IaC) tools like ARM templates, Terraform, or Pulumi have traditionally been used to define and manage infrastructure separately from application code. With .NET Aspire, some of this infrastructure definition moves into the application code itself. For example, you can define role-based access controls (RBAC) directly within your application:

var storage = builder.AddAzureStorage("mystorage")
.WithRoleAssignment("StorageBlobDataOwner", "myapp");

This approach allows developers to manage integrations, roles, and boundaries directly within their applications. However, it’s important to carefully manage security and coordinate between application-level and platform-level IaC to ensure a secure and efficient system.

Where Does IaC Fit In?

While .NET Aspire enables developers to define much of their application’s infrastructure, traditional IaC tools still play a crucial role in managing broader infrastructure aspects like networking, firewalls, and overall system isolation. IaC ensures that the system is securely set up and provides the necessary access points for applications to function correctly.

Conclusion

.NET Aspire represents a shift towards integrating application development and infrastructure management. By allowing developers to define infrastructure needs within their application code, it provides greater control and streamlines the development process. However, traditional IaC tools remain essential for managing the broader infrastructure environment, ensuring security, and maintaining system integrity.

Understanding Garbage Collection - How the dotnet Garbage Collector Works

Wed, 05 Feb 2025 13:27:20 +0000

Garbage collection (GC) is a fundamental component of the .NET runtime, responsible for managing memory automatically and ensuring efficient use of resources. With .NET 8, Microsoft has continued refining the garbage collector, improving performance, reducing latency, and enhancing overall efficiency. This article dives into how the .NET 8 GC works, its key improvements, and how developers can optimise memory usage.

How the .NET 8 Garbage Collector Works

The .NET 8 garbage collector operates as a generational, concurrent, and compacting GC. This means it divides objects into different generations based on their lifespan, collects garbage in a way that minimises application pauses, and compacts memory to reduce fragmentation. Here’s a breakdown of its key components:

Generational Garbage Collection

.NET’s GC follows a generational approach, classifying objects into three generations:

Generation 0 (Gen 0): Short-lived objects such as temporary variables and method-scoped objects.
Generation 1 (Gen 1): Objects that survived at least one GC cycle, acting as a buffer between Gen 0 and Gen 2.
Generation 2 (Gen 2): Long-lived objects such as static data, caches, and application-wide objects.

When the GC runs, it primarily collects Gen 0 objects, since they are short-lived. If memory pressure persists, it progresses to Gen 1 and eventually to a full GC (Gen 2), which is more expensive.

Concurrent and Background Collection

To improve performance, .NET 8’s GC includes background collection:

Concurrent GC: Allows the application to continue running while the GC reclaims memory.
Background GC: Used for Gen 2 collections to minimise blocking, keeping latency low for large applications.

These optimisations are particularly beneficial for real-time applications like web servers and gaming engines, where low-latency memory management is critical.

Compacting and Memory Fragmentation Reduction

As objects are allocated and freed, memory fragmentation can occur. The .NET GC mitigates this by compacting memory, moving surviving objects closer together to create larger free memory blocks. This improves cache locality and reduces memory pressure.

Pinned Objects and LOH (Large Object Heap) Handling

Pinned Objects: Some objects (e.g., those used in interop with native code) cannot be moved, which can lead to fragmentation. The GC optimises handling of pinned objects to reduce their impact on performance.
Large Object Heap (LOH): Objects larger than 85 KB are allocated in the LOH. .NET 8 includes improved LOH compaction to prevent excessive fragmentation.

What’s New in .NET 8 Garbage Collection?

.NET 8 introduces several key improvements to the GC:

Better Workload-Based Optimisations: The GC now adapts more effectively to different workloads, making it more efficient in cloud and high-performance applications.
Improved Memory Compaction Heuristics: Smarter algorithms decide when to compact memory, reducing unnecessary performance overhead.
Reduced Lock Contention in Multi-Threaded Environments: Enhancements in the GC’s locking mechanisms help prevent contention, particularly in multi-core environments.
Lower Latency for Interactive Applications: Optimisations ensure that UI and real-time applications experience fewer interruptions due to garbage collection.

How to Optimise for .NET 8’s GC

While the .NET GC is highly optimised, developers can still take steps to improve performance:

Reduce Unnecessary Object Allocations
- Use structs instead of classes for small, short-lived objects.
- Avoid excessive boxing/unboxing of value types.
Use Object Pooling
- Consider using ObjectPool<T> from Microsoft.Extensions.ObjectPool to reuse objects instead of frequently allocating and deallocating them.
Minimise Large Object Heap Usage
- Keep objects under 85kb when possible to avoid frequent LOH allocations.
- Reuse large objects instead of allocating new ones.
Be Mindful of Pinned Objects
- Use pinning sparingly, as it can lead to memory fragmentation.
Monitor and Profile GC Performance
- Use dotnet-counters, dotnet-trace, or PerfView to analyse GC performance and identify bottlenecks.

Conclusion

The .NET 8 garbage collector is more efficient than ever, thanks to optimisations in concurrency, fragmentation management, and workload adaptability. By understanding its inner workings and applying best practices, developers can write more performant applications with minimal memory-related bottlenecks. Whether you’re building a high-throughput server, a responsive UI application, or a cloud-native service, optimising for the .NET 8 GC will help ensure smooth and efficient memory management.

Why C# Developers Should Also Learn Rust, and What It Can Teach Them

Sun, 19 Jan 2025 17:02:14 +0000

As a C# developer, you might wonder why you should invest time learning Rust, a systems programming language. After all, C# is a powerful, versatile, and high-level language with a vast ecosystem and a wide range of applications. However, learning Rust can expand your programming horizons and provide unique insights that will make you a better developer, regardless of your primary language. Here’s why C# developers should consider learning Rust and what they can gain from it.

Understanding Ownership and Memory Management

In C#, memory management is largely handled by the .NET runtime and its garbage collector, which simplifies development. Rust, on the other hand, introduces a novel ownership model with strict compile-time checks that ensure memory safety without relying on garbage collection.

By learning Rust, C# developers gain a deeper appreciation for:

How memory is allocated and deallocated.
Avoiding common pitfalls like null references and memory leaks.
Writing performance-critical code with deterministic resource management.

This knowledge can directly help C# developers optimise their applications by being more mindful of how objects are created, used, and disposed of, reducing pressure on the garbage collector and improving runtime performance.

Example:

Rust Code:

fn main() {
let s = String::from("Hello, Rust!"); // Ownership of the string
 println!("{}", s);
// The string is automatically deallocated when it goes out of scope
}

C# Equivalent:

using System;
class Program {
static void Main() {
string s = "Hello, C#!";
Console.WriteLine(s);
// The garbage collector will clean up the string eventually
 }
}

Writing Safer and More Reliable Code

Rust’s emphasis on safety goes beyond memory management. Its powerful type system and strict compiler checks help prevent issues like data races, uninitialised variables, and mismatched types at compile time.

For C# developers, learning Rust can:

Reinforce the habit of thinking through edge cases.
Highlight the value of immutability and its role in creating thread-safe code.
Encourage writing more robust code by embracing patterns that reduce runtime errors.

Example:

Rust Code:

fn divide(a: i32, b: i32) -> Option<i32> {
if b == 0 {
None // Avoid division by zero
 } else {
Some(a / b)
}
}

C# Equivalent:

class Program {
static int? Divide(int a, int b) {
if (b == 0) {
return null; // Avoid division by zero
 } else {
return a / b;
}
}
}

Performance and Low-Level Systems Programming

Rust is designed for high performance, making it ideal for systems programming, game development, and scenarios requiring fine-grained control over hardware resources. While C# is fast and efficient for many applications, Rust allows you to:

Optimise critical parts of your application where performance matters most.
Understand the hardware-level implications of your code, such as how data is laid out in memory.
Develop cross-platform libraries or tools with minimal overhead.

Even if you don’t use Rust directly in your projects, this knowledge can help you better understand performance bottlenecks in C# applications. For example, by learning about data-oriented design in Rust, you can improve cache locality and memory access patterns in performance-critical C# code, leading to faster execution times.

Example:

Rust Code (Efficient Loop):

let data = vec![1, 2, 3, 4, 5];
for &item in data.iter() {
println!("{}", item);
}

C# Equivalent:

var data = new[] { 1, 2, 3, 4, 5 };
foreach (var item in data) {
Console.WriteLine(item);
}

A Broader Perspective on Concurrency

Concurrency is a common challenge in modern software development. While C# provides powerful abstractions like async/await and the Task Parallel Library, Rust takes a different approach by enforcing thread safety at compile time.

By exploring Rust’s model for concurrency, you’ll:

Gain new tools for reasoning about shared state.
Learn how to write concurrent code without fear of data races.
Appreciate how Rust’s borrow checker prevents common multithreading bugs.

Example:

Rust Code:

use std::thread;
fn main() {
let data = vec![1, 2, 3];
let handle = thread::spawn(move || {
for i in data {
println!("{}", i);
}
});
handle.join().unwrap();
}

C# Equivalent:

using System;
using System.Threading;
using System.Threading.Tasks;
class Program {
static async Task Main() {
var data = new[] { 1, 2, 3 };
await Task.Run(() => {
foreach (var item in data) {
Console.WriteLine(item);
}
});
}
}

Embracing a New Way of Thinking

Learning a language like Rust, with its unique paradigms and constraints, challenges you to think differently about programming. It encourages you to:

Be more deliberate in your coding decisions.
Appreciate the trade-offs between safety, performance, and expressiveness.
Explore functional programming concepts like pattern matching and closures, which can also be applied in C#.

This shift in perspective can lead to writing more efficient and elegant C# code. For instance, understanding how Rust optimises for zero-cost abstractions might inspire you to rethink how you structure performance-critical sections of your C# programs.

Expanding Career Opportunities

As Rust grows in popularity, demand for Rust developers is increasing in fields like blockchain, embedded systems, and cloud infrastructure. Adding Rust to your skill set not only broadens your technical expertise but also opens up new career paths that might not be accessible with C# alone.

Conclusion

Learning Rust can be a transformative experience for C# developers. It deepens your understanding of memory management, safety, performance, and concurrency while challenging you to approach problems from a new perspective. Even if you continue to primarily work in C#, the lessons you learn from Rust can make you a more thoughtful, efficient, and versatile developer.

By applying these insights to your C# projects, you can write optimised, high-performance applications that are safer and more reliable. So, why not give Rust a try? You might discover a new way to solve problems—and in the process, elevate your skills in both languages.

Why Frontend Software Development Is Needlessly Complex, When It Does Not Need to Be

Thu, 02 Jan 2025 14:08:41 +0000

Frontend software development has evolved drastically over the last decade, transforming from simple static HTML pages to dynamic, interactive web applications. While the growth of the field has unlocked new possibilities, it has also introduced layers of complexity that, arguably, aren’t always necessary. The question worth asking is: why has frontend development become so convoluted, and does it really need to be this way?

The Rise of Complexity

The world of frontend development today is a maze of frameworks, libraries, and tools. Angular, React, Vue, Svelte—each promises to simplify development, yet their adoption often comes with steep learning curves. Add to this the tooling required for bundling (Webpack, Vite, or Rollup), testing (Jest, Cypress, or Mocha), and linting (ESLint, Prettier), and it’s easy to see how a straightforward task can balloon into an overwhelming endeavor.

The justification for this complexity often stems from the demand for highly performant, scalable, and maintainable applications. Businesses want rich user interfaces, rapid load times, and the ability to handle millions of users. While these goals are valid, they don’t always apply universally. Many applications don’t need the latest cutting-edge features, yet developers still adopt over-engineered solutions by default.

Where We Went Wrong

Over-Abstraction: Frameworks and libraries abstract away many of the complexities of browser behavior and DOM manipulation. While abstractions can be powerful, they often lead to situations where developers spend more time understanding the abstraction than solving actual problems.
Dependency Overload: The npm ecosystem encourages a dependency-first approach, where every problem seems to have a package. This results in bloated applications, dependency conflicts, and security vulnerabilities.
Tooling Fatigue: The sheer number of tools required to set up a modern development environment can be intimidating. Do we really need a full CI/CD pipeline, TypeScript integration, and CSS-in-JS for a simple blog?
Chasing Trends: The rapid pace of innovation in frontend development means new tools and practices emerge regularly. Developers often feel pressure to keep up with trends, leading to unnecessary rewrites and added complexity.

What Can Be Done?

Embrace Simplicity: Not every project requires a heavyweight framework. For smaller applications, vanilla JavaScript or lightweight libraries like Alpine.js can suffice.
Right-Sizing Abstractions: Use abstractions that genuinely add value to your project. Avoid abstracting for the sake of it; focus on tools and patterns that solve real problems.
Mindful Tooling: Streamline your development workflow. Choose tools that align with your project’s needs rather than defaulting to industry standards.
Educate and Advocate: Encourage teams to question the necessity of each layer of complexity. Build a culture where it’s okay to say no to new tools or paradigms when they’re not needed.
Focus on Fundamentals: Solid understanding of HTML, CSS, and JavaScript remains invaluable. Mastery of the basics often reduces the perceived need for complex frameworks.

Conclusion

Frontend development doesn’t have to be a labyrinth of complexity. By challenging the status quo, focusing on simplicity, and making intentional choices, we can build robust applications without unnecessary overhead. Let’s shift the narrative from “what’s trending?” to “what’s practical?” The result will be better software and happier developers.

Linux Is NOT the Developers Paradise You Have Been Told It Is

Wed, 11 Dec 2024 10:55:23 +0000

Linux is often heralded as the holy grail for developers - a flexible, open-source playground free of corporate shackles. It’s the darling of the tech-savvy, the underdog in the OS wars, and the supposed utopia for programmers everywhere. But let’s take a step back from the hype. While Linux has its merits, it’s not the flawless paradise that some people claim. Here’s why.

It’s a Compatibility Nightmare

Linux offers unparalleled customisation, but it comes at a cost - compatibility. Hardware support can be hit or miss, especially with niche devices or newer tech. Developers often find themselves scouring forums, compiling drivers, or tweaking configurations just to get basic peripherals working.

Even on the software side, compatibility can be an issue. Need Adobe Creative Suite? Tough luck. Want to play nice with proprietary enterprise software? You’re likely stuck with virtual machines or dual-booting.

The Endless Tinkering

Linux’s endless customisation options are a double-edged sword. While some developers revel in the ability to tweak every aspect of their system, others fall into a productivity black hole. Hours that could be spent coding are instead consumed by perfecting your desktop environment, troubleshooting obscure bugs, or optimising performance for the nth time.

For developers working on tight deadlines or in professional environments, this can quickly become a liability.

Fractured Ecosystem

One of Linux’s greatest strengths is also its biggest weakness - its diversity/fragmentation. With countless distributions (distros) to choose from, there’s a flavor of Linux for everyone. But this fragmentation leads to inconsistency.

Developers often face compatibility issues between distros, forcing them to either standardise on one or deal with the quirks of multiple environments. Tutorials and documentation are often written for specific distros, leaving newcomers bewildered when commands or features don’t translate.

The Learning Curve

Linux is not inherently user-friendly, especially for developers who are new to the ecosystem. Learning the ins and outs of the command line, navigating cryptic error messages, and understanding Linux file systems can be daunting.

For developers with limited time to spare, this steep learning curve can feel like an unnecessary hurdle, particularly when other operating systems like macOS or Windows offer more intuitive experiences.

Corporate Resistance

While Linux thrives in server environments, its adoption as a desktop OS in corporate settings remains limited. Developers working in enterprise environments often find themselves shackled to Windows or macOS, which offer better support for proprietary tools and enterprise-grade software.

Even if a developer prefers Linux, the corporate world’s reliance on other operating systems often makes switching impractical.

So, What Now?

To be clear, Linux is a powerful, versatile, and exciting operating system. For the right developer - someone who values freedom, thrives on problem-solving, and isn’t afraid to get their hands dirty - it can be a dream come true. But for many others, it’s not the paradise it’s cracked up to be.

The next time someone tells you that Linux is the only OS for serious developers, take their advice with a grain of salt. The perfect operating system doesn’t exist - it’s about finding what works best for your needs, whether that’s Linux, Windows, macOS, or even a combination of them.

What’s your take on Linux? Have you found it to be a paradise, a nightmare, or something in between? Let us know in the comments below!

Why Do Open Source Applications Often Have Less Polished UIs Than Commercial Software

Thu, 05 Dec 2024 23:02:00 +0000

Open-source applications play a critical role in technology, offering powerful tools, innovation, and community-driven development. However, many users have noticed that the user interfaces (UIs) of open-source software often lack the polish and finesse of their commercial, closed-source counterparts. This perceived gap isn’t due to a lack of talent but arises from unique challenges and priorities inherent to open-source projects.

Resource Allocation: Priorities Over Aesthetics

Open-source projects often prioritize functionality, performance, and robustness over visual design. Since most contributors are developers who are solving specific problems, their focus naturally leans towards creating software that works rather than one that looks visually appealing.

On the other hand, commercial software companies have dedicated budgets to hire UI/UX designers, whose primary role is to craft an attractive and intuitive user experience. In contrast, open-source projects rarely have the financial resources to prioritize such roles.

Volunteer-Driven Development

Open-source projects rely heavily on volunteers. These contributors typically work on the project in their free time and focus on areas where they have expertise or personal interest. Since skilled UI/UX designers are in high demand in the commercial sector, they are less likely to volunteer their time for open-source initiatives.

Without a dedicated team addressing the aesthetics, UI improvements are often delayed or entirely neglected in favor of core functionality.

User Base Expectations

The user base of open-source software often consists of tech-savvy individuals, developers, and businesses that prioritize customization, control, and functionality over design. For these users, a polished UI may feel less critical than having open access to the software’s source code or ensuring compatibility with niche requirements.

Conversely, commercial software is marketed to a broader audience, including non-technical users who place higher importance on an intuitive and visually pleasing interface.

The Challenge of Design Consistency

Open-source projects frequently have many contributors with diverse visions and styles, making it difficult to maintain a consistent design language across the application. This lack of cohesion can result in interfaces that feel disjointed or unintuitive.

Commercial software benefits from a centralized vision. Design guidelines, brand standards, and dedicated leadership ensure a uniform look and feel across every feature and update.

Iterative Design Processes in Open Source

Open-source UIs often evolve in response to user feedback, which can lead to patchwork changes rather than comprehensive redesigns. While this approach ensures practical usability, it can leave the software feeling less cohesive and modern compared to commercial applications that undergo extensive user testing and iterative design processes.

Monetary Incentives and Competitive Pressure

Commercial software faces immense competition in the market, pushing companies to invest heavily in eye-catching, user-friendly interfaces to stand out. Features are often marketed through sleek, demo-ready designs that appeal to potential buyers.

Open-source software, on the other hand, does not operate on the same profit-driven model. Its success is often measured by its adoption rate and community contributions, where design appeal plays a secondary role.

Closing the Gap

Despite these challenges, many open-source projects are beginning to prioritize UI improvements. Projects like LibreOffice, GIMP, and Blender have made significant strides in modernizing their interfaces, thanks to increased community awareness of the importance of design. Some open-source initiatives also fundraise to hire professional designers or offer grants to contributors with UI/UX expertise.

Collaborations between open-source communities and design professionals could help bridge the gap, creating software that is both functionally powerful and visually appealing.

Conclusion

The less-polished UIs of open-source software stem from structural differences in priorities, funding, and resources compared to commercial software. However, as the importance of design continues to grow, open-source communities are finding ways to address these challenges. With time, we may see more open-source applications boasting UIs that rival their commercial counterparts, combining the best of functionality and form.

My Top 6 Productivity Tools as C# Developer

Wed, 04 Dec 2024 13:56:23 +0000

As a C# developer, I have a wealth of tools at my disposal, each designed to make coding, debugging, and deployment easier, or more efficient. Whether you’re new to the language, or programming in general, or even an experienced developer, leveraging these tools can significantly enhance your productivity. So these are my six essential tools every C# programmer should use:

Visual Studio

The powerhouse for C# development.

Visual Studio is more than just an IDE—it’s a complete development environment tailored to C# and .NET developers. Its key features include:

IntelliSense: Provides intelligent code suggestions as you type, reducing errors and speeding up coding.
Built-in Debugger: An intuitive debugger with breakpoint management, variable inspection, and real-time execution flow control.
Rich Extension Ecosystem: From testing frameworks to design tools, Visual Studio supports a vast library of extensions.

For those who want a faster, more lightweight option, Visual Studio Code paired with the C# by OmniSharp extension offers essential functionality like debugging, linting, and IntelliSense. It’s ideal for smaller projects or developers who prefer cross-platform development.

ReSharper

Elevate your coding experience.

ReSharper by JetBrains is a premium tool for Visual Studio that enhances your coding workflow by analyzing your code in real time. Its features include:

Code Refactoring: Automatically improve the structure of your code without altering its behavior.
Code Analysis: Detects potential issues, such as unused variables or inefficient code patterns, as you write.
Navigation Tools: Quickly locate classes, methods, or files in large projects with powerful search capabilities.

ReSharper’s ability to suggest improvements and automate repetitive tasks makes it invaluable for maintaining clean, efficient, and maintainable code.

LINQPad

Test and prototype with ease.

LINQPad is not just a tool for running LINQ queries—it’s an interactive coding environment for C#. Its capabilities include:

Prototyping: Test small snippets of C# code without setting up a full project. This is perfect for debugging algorithms or trying out new ideas.
Database Integration: Query SQL databases with LINQ and view the results instantly.
.NET Exploration: Dive deep into the .NET Framework with examples and interactive tutorials.

The ability to run and test code in a standalone environment makes LINQPad a great tool for experimentation and learning.

Postman

Streamline API interactions.

Postman is an essential tool for developers working with APIs, which are increasingly central to modern applications. Its features are tailored to make API testing seamless:

Request Crafting: Easily create GET, POST, PUT, DELETE, and other HTTP requests with custom headers, parameters, and body content.
Response Validation: Check the responses from APIs to ensure they meet your application’s requirements.
Automation: Save collections of API calls, automate tests, and even integrate them into CI/CD pipelines for ongoing validation.

Postman is particularly useful for C# developers building web applications or consuming third-party APIs, as it ensures smooth integration and functionality.

Fiddler

Debugging network traffic made easy.

When building web applications or services, understanding and troubleshooting network requests is crucial. Fiddler is a powerful tool for inspecting network activity:

Traffic Monitoring: View all HTTP and HTTPS traffic between your application and servers.
Request Manipulation: Edit and replay requests to test how your application responds under different scenarios.
Performance Analysis: Identify and resolve latency issues, bottlenecks, or misconfigured requests.

Fiddler is especially valuable for diagnosing connectivity issues in APIs or web services and ensuring your applications communicate effectively with external systems.

Azure DevOps

Manage projects and streamline deployment.

Azure DevOps is a comprehensive suite of tools for planning, developing, and deploying applications. C# developers benefit from its seamless integration with the .NET ecosystem. Key features include:

Work Management: Use Kanban boards, backlogs, and work items to plan and track development tasks.
Build and Release Pipelines: Automate building, testing, and deploying your C# applications across environments.
Collaboration Tools: Integrate code repositories, manage pull requests, and collaborate with your team efficiently.

Azure DevOps empowers teams to adopt DevOps practices, improving the overall development lifecycle from coding to deployment.

Honorable Mentions

Dapper: A lightweight ORM for fast and efficient database queries, especially useful for developers seeking alternatives to Entity Framework.
Rider: JetBrains’ cross-platform IDE for .NET development, offering performance comparable to Visual Studio with a fresh user interface.
Notepad++ or Sublime Text: Simple yet powerful text editors ideal for quick edits or reviewing code outside the IDE.

Conclusion

C# programmers have access to a variety of tools that cater to every stage of the development lifecycle. From coding and debugging to testing and deployment, integrating these tools into your workflow can significantly boost productivity.

Have a favorite tool that didn’t make the list? Share your recommendations and tips to help other C# developers level up their workflows!

What would you have added to this list, and why?

Why C# Should Be Your First Language and is the Best Programming Language for Beginners

Tue, 03 Dec 2024 23:41:41 +0000

When choosing your first programming language, the decision can feel overwhelming. With so many languages available, each with unique strengths, you might wonder, Where should I start? Enter C#—a powerful, versatile, and beginner-friendly language. In this article, we’ll explore why C# stands out as the best choice for beginners, backed by its features, community, and versatility.

C# is a C-Based Language

C# has its roots in the C family of programming languages, which includes heavyweights like C, C++, and Java. This lineage gives it a syntax that’s familiar and widely adopted.

Learning C# provides an excellent foundation for transitioning to other C-based languages in the future. Concepts like loops, conditionals, and object-oriented programming (OOP) are implemented in a way that closely mirrors other popular languages, making it easier to pick up Java, JavaScript, or even C++ later in your journey.

A Large and Supportive Community

One of the most significant hurdles for beginners is troubleshooting issues and finding learning resources. Thankfully, C# boasts a large and active community.

Whether you’re seeking help on forums like Stack Overflow, diving into tutorials on YouTube, or exploring documentation, there’s no shortage of guidance. Microsoft’s official resources, coupled with open-source communities, ensure that answers are never far away.

Open Source and Free to Use

C# is part of the open-source .NET ecosystem, which means the language, tools, and frameworks are freely available. For a beginner, this removes the barrier of expensive licenses or proprietary restrictions. You can write, debug, and deploy your first application without spending a dime.

Cross-Platform Development

With the introduction of .NET Core, C# has become a cross-platform powerhouse. You can develop applications that run seamlessly on Windows, macOS, and Linux. This versatility is invaluable in today’s world, where software often needs to work across diverse environments. For beginners, this means you can experiment and deploy projects without worrying about platform constraints.

Mature and Beginner-Friendly Toolset

C# is backed by a mature and polished ecosystem of tools, most notably Visual Studio and Visual Studio Code. These integrated development environments (IDEs) offer powerful features like:

IntelliSense: Real-time code suggestions that help you write error-free code faster.
Debugging Tools: Step through your code line by line to identify and fix issues.
Templates: Ready-made project structures to kickstart your learning.

These tools reduce the steepness of the learning curve, helping you focus on understanding programming concepts without being bogged down by setup complexities.

Object-Oriented Programming (OOP)

C# is built with object-oriented principles at its core. OOP is a paradigm that’s easy to understand and widely used across the industry. By learning C#, you gain a solid grasp of concepts like:

Classes and Objects
Inheritance
Encapsulation
Polymorphism

These principles are transferable to other programming languages and essential for tackling complex projects.

Versatility Across Applications

C# isn’t just for one type of application. It powers:

Desktop Apps (e.g., Windows Forms, WPF)
Web Apps (e.g., ASP.NET)
Game Development (e.g., Unity Engine)
Mobile Apps (e.g., Xamarin and .NET MAUI)
Cloud Services (e.g., Azure integration)

This versatility means you can explore various domains as you grow, from game development to web design, all with the same language.

Strong Career Opportunities

C# is in high demand across industries. By learning C#, you’re not just acquiring a skill for hobby projects; you’re also building a foundation for a lucrative and stable career. Major companies like Microsoft, Unity, and Stack Overflow rely heavily on C#, ensuring its relevance for years to come.

Conclusion

C# strikes the perfect balance for beginners: it’s accessible yet powerful, versatile yet structured. Its C-based syntax, thriving community, open-source nature, cross-platform support, and robust toolset make it an ideal choice for anyone starting their programming journey.

By choosing C#, you’re not just learning a language—you’re stepping into an ecosystem that will grow with you, offering endless opportunities for personal and professional development. So, fire up your IDE and start coding; the world of C# awaits!

How To: Create a Basic GraphQL API with dotnet in C#

Sat, 09 Nov 2024 19:10:09 +0000

GraphQL is better than OData, and REST… So this guide will show you how to create a GraphQL API allows you to offer a flexible data querying interface where clients can request exactly the data they need. Here, we’ll create a simple GraphQL API in C# that returns data about music artists and their albums.

Prerequisites

To follow along, you need to make sure that you have:

.NET SDK (version 5 or later)
Familiarity with ASP.NET Core
GraphQL for .NET library

You can download the .NET SDK from the .NET website.

Set Up Your Project

Create a new ASP.NET Core Web API project:

dotnet new webapi -n GraphQLMusicApi
cd GraphQLMusicApi

Add the GraphQL.NET package:

dotnet add package GraphQL --version 4.6.1

Add ASP.NET Core GraphQL integration:

dotnet add package GraphQL.Server.Transports.AspNetCore --version 5.0.0

Define Your Data Models

For this example, we’ll create two simple models: Artist and Album.

public class Artist
{
public int Id { get; set; }
public string Name { get; set; }
public List<Album> Albums { get; set; }
}
public class Album
{
public int Id { get; set; }
public string Title { get; set; }
public int Year { get; set; }
}

Next, we’ll create a data repository to act as our data source.

public class MusicRepository
{
private readonly List<Artist> _artists = new List<Artist>
{
new Artist {
Id = 1,
Name = "The Beatles",
Albums = new List<Album>
{
new Album { Id = 1, Title = "Abbey Road", Year = 1969 },
new Album { Id = 2, Title = "Let It Be", Year = 1970 }
}
},
new Artist {
Id = 2,
Name = "Pink Floyd",
Albums = new List<Album>
{
new Album { Id = 3, Title = "The Dark Side of the Moon", Year = 1973 },
new Album { Id = 4, Title = "Wish You Were Here", Year = 1975 }
}
}
};
public IEnumerable<Artist> GetAllArtists() => _artists;
public Artist GetArtistById(int id) => _artists.FirstOrDefault(a => a.Id == id);
}

Define the GraphQL Schema

With GraphQL, we need to define types and queries for our models.

Create the Album GraphQL Type:

using GraphQL.Types;
public class AlbumType : ObjectGraphType<Album>
{
public AlbumType()
{
Field(x => x.Id).Description("The ID of the album.");
Field(x => x.Title).Description("The title of the album.");
Field(x => x.Year).Description("The release year of the album.");
}
}

Create the Artist GraphQL Type:

public class ArtistType : ObjectGraphType<Artist>
{
public ArtistType()
{
Field(x => x.Id).Description("The ID of the artist.");
Field(x => x.Name).Description("The name of the artist.");
Field<ListGraphType<AlbumType>>("albums", "The albums by the artist");
}
}

Define the Query Class:

This class defines the queries for retrieving artists and albums.

public class MusicQuery : ObjectGraphType
{
public MusicQuery(MusicRepository repository)
{
Field<ListGraphType<ArtistType>>(
"artists",
resolve: context => repository.GetAllArtists()
);
Field<ArtistType>(
"artist",
arguments: new QueryArguments(new QueryArgument<IntGraphType> { Name = "id" }),
resolve: context =>
{
var id = context.GetArgument<int>("id");
return repository.GetArtistById(id);
}
);
}
}

Create the Schema:

public class MusicSchema : Schema
{
public MusicSchema(IServiceProvider provider) : base(provider)
{
Query = provider.GetRequiredService<MusicQuery>();
}
}

Set Up Dependency Injection and Middleware

To use these services, add them to the service collection and configure middleware in Startup.cs.

Configure Services:

public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<MusicRepository>();
services.AddSingleton<AlbumType>();
services.AddSingleton<ArtistType>();
services.AddSingleton<MusicQuery>();
services.AddSingleton<ISchema, MusicSchema>();
services.AddGraphQL(options =>
{
options.EnableMetrics = false;
}).AddSystemTextJson();
}

Configure Middleware:

In the Configure method, set up the GraphQL endpoint:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapGraphQL("/graphql");
});
}

Test Your API

Run your application:
```
dotnet run
```
Navigate to http://localhost:5000/graphql. You can test the API using a tool like GraphiQL or Postman.

Example Queries:

To get all artists and their albums:

query {
artists {
id
name
albums {
title
year
}
}
}

To get a specific artist by ID:

query {
artist(id: 1) {
name
albums {
title
year
}
}
}

Wrapping Up

With just a few steps, you’ve created a GraphQL API for music artists and albums. This basic API can be expanded with more complex types, queries, and mutations as needed, offering powerful data flexibility for your clients. Happy coding!

SOLID Design Principles Rust (with examples)

Fri, 25 Oct 2024 10:31:56 +0100

When it comes to designing software, the SOLID principles are the gold standard for object-oriented programming. While Rust isn’t an object-oriented language in the strictest sense, it offers plenty of tools to apply SOLID principles effectively. With enums, traits, and strict type safety, Rust provides a solid foundation for building flexible, maintainable, and robust applications that adhere to these design principles.

Single Responsibility Principle (SRP)

The Single Responsibility Principle states that a struct or function should have one, and only one, reason to change. In Rust, this translates into modules, structs, and functions that each handle a single task.

For example, consider a simple logging system:

// Logger only handles logging.
struct Logger;
impl Logger {
fn log(&self, message: &str) {
println!("Log: {}", message);
}
}
// FileProcessor is responsible for file processing only.
struct FileProcessor {
logger: Logger,
}
impl FileProcessor {
fn process_file(&self, filename: &str) {
// Process the file (e.g., reading content)
 self.logger.log("Processing file...");
}
}

Here, Logger handles logging, and FileProcessor processes files. By separating these responsibilities, we make each component independently modifiable and testable.

Open/Closed Principle (OCP)

The Open/Closed Principle states that modules should be open for extension but closed for modification. In Rust, this often involves using enums or trait-based polymorphism.

Consider a payment system with multiple payment methods:

trait Payment {
fn pay(&self, amount: f32);
}
struct CreditCard;
impl Payment for CreditCard {
fn pay(&self, amount: f32) {
println!("Paid ${} with credit card.", amount);
}
}
struct Paypal;
impl Payment for Paypal {
fn pay(&self, amount: f32) {
println!("Paid ${} using PayPal.", amount);
}
}
fn process_payment(payment: &dyn Payment, amount: f32) {
payment.pay(amount);
}

Here, Payment is a trait that new payment methods can implement without modifying existing code. By adhering to OCP, we make it easy to add new payment methods without disrupting the existing process_payment logic.

Liskov Substitution Principle (LSP)

The Liskov Substitution Principle asserts that objects of a superclass should be replaceable with objects of a subclass without altering the correctness of the program. In Rust, this is less about inheritance and more about implementing traits in a consistent way.

Imagine an example of drawing shapes:

trait Drawable {
fn draw(&self);
}
struct Circle;
impl Drawable for Circle {
fn draw(&self) {
println!("Drawing a circle.");
}
}
struct Square;
impl Drawable for Square {
fn draw(&self) {
println!("Drawing a square.");
}
}
fn render_shape(shape: &dyn Drawable) {
shape.draw();
}

Both Circle and Square implement the Drawable trait, making them interchangeable in render_shape. Thus, we follow the LSP by ensuring both types can replace each other in code that uses Drawable.

Interface Segregation Principle (ISP)

The Interface Segregation Principle says that clients should not be forced to depend on interfaces they don’t use. In Rust, this is typically achieved by using smaller, focused traits.

Consider a printer and scanner:

trait Printer {
fn print(&self, document: &str);
}
trait Scanner {
fn scan(&self) -> String;
}
struct AllInOneDevice;
impl Printer for AllInOneDevice {
fn print(&self, document: &str) {
println!("Printing: {}", document);
}
}
impl Scanner for AllInOneDevice {
fn scan(&self) -> String {
"Scanned document content".to_string()
}
}

Here, we separate the Printer and Scanner traits, allowing devices that only print or scan to implement only what they need. This keeps the interface minimal and clean, aligning with the ISP.

Dependency Inversion Principle (DIP)

The Dependency Inversion Principle promotes depending on abstractions, not concretions. In Rust, traits provide a great way to inject dependencies and reduce coupling between modules.

Consider a notification system where we can notify users via email or SMS:

trait Notifier {
fn send(&self, message: &str);
}
struct EmailNotifier;
impl Notifier for EmailNotifier {
fn send(&self, message: &str) {
println!("Sending email: {}", message);
}
}
struct SmsNotifier;
impl Notifier for SmsNotifier {
fn send(&self, message: &str) {
println!("Sending SMS: {}", message);
}
}
struct UserNotifier<'a> {
notifier: &'a dyn Notifier,
}
impl<'a> UserNotifier<'a> {
fn notify_user(&self, message: &str) {
self.notifier.send(message);
}
}

By using a trait (Notifier) as an abstraction, we can easily inject any type of notifier (EmailNotifier, SmsNotifier) into UserNotifier. This flexibility makes the code easier to test and extend.

Why Rust and Its Memory Safety Lulls Developers Into a False Sense of Security, Leading to More Serious Bugs

Wed, 02 Oct 2024 23:49:04 +0100

Rust has garnered significant attention in the programming world for its focus on memory safety without the need for a garbage collector, making it an appealing option for systems programming, where safety and performance are both critical. By preventing entire categories of bugs like data races, buffer overflows, and null pointer dereferencing at compile time, Rust has earned a reputation as a “safe” language. However, this very focus on memory safety can lull developers into a false sense of security, leading them to overlook other kinds of programming errors, potentially causing even more serious bugs. Here’s why.

The Memory Safety Halo Effect

Rust’s strong emphasis on memory safety creates a psychological effect on developers, often leading them to assume that because the compiler ensures memory is safely managed, other aspects of their code are automatically more secure or reliable. This “halo effect” can lead developers to lower their guard when it comes to other critical aspects of software engineering, such as concurrency, logic errors, or mismanaging external resources like file systems and databases.

While Rust can prevent certain classes of memory-related bugs, it cannot prevent logical errors, race conditions in non-shared state, or incorrect API usage. Developers who become over-reliant on the compiler’s safety checks may inadvertently write poorly architected or buggy code, believing that the language’s safety features will catch more than they actually do.

The Complexity of the Borrow Checker Can Encourage Riskier Designs

Rust’s borrow checker is at the core of its memory safety model, ensuring that variables have a clear ownership model. However, the complexity of managing ownership, borrowing, and lifetimes can lead to situations where developers “fight the borrow checker,” making design compromises just to satisfy the compiler, even when those choices aren’t ideal for the problem at hand.

In some cases, developers may opt to use unsafe blocks—portions of code where the compiler’s memory checks are explicitly disabled—in an effort to work around borrow checker limitations. This, ironically, opens up the very memory safety vulnerabilities Rust is meant to prevent. Overuse or improper use of unsafe can introduce subtle, hard-to-diagnose bugs that would not exist if the developer had chosen a simpler language without Rust’s safety guarantees.

Overconfidence in Safe APIs

Rust’s ecosystem provides many “safe” APIs that abstract away complexity and ensure memory safety, but using them incorrectly can still lead to serious issues. For instance, using concurrency libraries like async and await can lead to deadlocks, race conditions, or resource contention if not used with care. Rust cannot prevent you from misusing these abstractions, and the safety checks at compile time don’t address the runtime issues that come with distributed systems or multithreading.

Developers may assume that because Rust promotes memory safety, the libraries or patterns they use are inherently safe from a broader software engineering standpoint. This overconfidence can lead to critical oversights, where the developer fails to consider edge cases, performance pitfalls, or non-memory-related errors like invalid data processing or incomplete error handling.

Increased Cognitive Load Leading to Mistakes Elsewhere

While Rust does an excellent job of enforcing safe memory access, managing ownership, borrowing, and lifetimes requires a steep learning curve and significant cognitive overhead. Developers may spend more mental energy wrestling with the compiler to satisfy memory safety constraints, leaving them with less bandwidth to focus on the actual problem their program is meant to solve.

This “cognitive tax” can lead to overlooked errors in higher-level logic, inadequate testing, or poor documentation. While memory is safe, the business logic of the application or the correctness of algorithms might suffer as a result of a developer’s attention being disproportionately absorbed by satisfying Rust’s strict compiler checks.

Misconceptions About What Rust Guarantees

Rust provides safety guarantees within the boundaries of its memory model, but those guarantees do not extend to the entire software stack. Many developers mistakenly believe that Rust’s guarantees extend to things like thread safety in all cases, deadlock prevention, or performance predictability. While Rust does help eliminate certain classes of bugs, it does not absolve developers from understanding concurrency issues, ensuring algorithmic efficiency, or mitigating performance bottlenecks in low-level systems.

When developers take for granted that Rust handles “all the hard stuff,” they may neglect performance tuning or fail to account for how their application behaves under load, leading to inefficiencies or runtime failures that Rust’s memory safety guarantees do not address.

Conclusion

Rust’s memory safety features are a double-edged sword. While they provide a strong safety net against memory-related bugs, they can also lull developers into a false sense of security that may cause them to overlook other, equally important aspects of programming. In many cases, this can lead to more serious or subtle bugs than one might encounter in languages that require more explicit management of memory but don’t impose the same cognitive overhead.

Ultimately, while Rust prevents many memory-related errors, it is not a magic bullet. Developers need to be aware of the language’s limitations, stay vigilant against overconfidence, and remember that writing safe and robust code requires more than just a good compiler—it requires careful thought and a comprehensive approach to software design.

Stop Designing Your Web Application for Millions of Users When You Don’t Even Have 100

Sun, 15 Sep 2024 22:05:07 +0100

It’s easy to get carried away when you’re building a new web app. You’ve got big ideas, you picture millions of users flocking to your platform, and you start imagining the kind of infrastructure needed to handle all that traffic. So, you build for scale from day one—optimising databases, setting up powerful servers, and ensuring everything is robust enough for massive growth.

But hold on a second. If you don’t even have 100 users yet, designing your app for millions is a massive overreach. In fact, it’s probably holding you back more than helping. Here’s why you should focus on the here and now, and stop worrying about a future that may be a long way off.

You Don’t Actually Know What You Need Yet

When you’re just starting out, you’re making a lot of guesses. You think you know what your users will want and how they’ll use your app, but the reality might be completely different. If you design your app to handle millions of users before you’ve even got your first 100, you’re making decisions based on assumptions rather than real data.

Your priority should be to build something people want to use. Once you’ve got a solid user base, you’ll have a much better idea of what kind of scaling you’ll actually need. For now, focus on building a product that meets the needs of your first users.

Over-Engineering Wastes Precious Time

In the early days, time is your most valuable resource. Spending weeks—or even months—perfecting infrastructure that won’t be needed for a while is time you’re not spending on more important things, like building features, improving the user experience, and getting feedback.

You don’t need a super-scalable solution from day one. You need something that works well for the users you have right now. You can always optimise for scale later on, but right now your focus should be on delivering value quickly.

Scaling Early Means Unnecessary Costs

Designing your app for millions of users is not just time-consuming, it’s also expensive. Building infrastructure for scale means investing in servers, databases, and cloud services that you don’t really need yet. These costs can quickly add up, and they’re not likely to pay off anytime soon if your user base is still in the double digits.

Wouldn’t that money be better spent on marketing, product development, or customer acquisition? Scaling infrastructure can wait until your user numbers justify it.

Speed and Flexibility Are Key

At this stage, what you need most is the ability to iterate quickly. You’re still figuring out exactly what your users want, and you’ll probably need to make lots of changes along the way. If you’ve built a complex, scalable system, even small changes can become a headache.

Keep things simple so that when you get feedback from users, you can adjust quickly. Flexibility is crucial in the early stages, and over-engineering makes you less nimble.

Your Future Problems Will Be Different

Even if you hit the jackpot and end up with millions of users, the challenges you face at that point will be very different from the ones you’re imagining now. The way your app works today will likely evolve, and you won’t really know what those future challenges look like until you get there.

So why waste time trying to solve problems you haven’t even encountered yet? Focus on the problems you do have—like finding product-market fit and getting your first few users through the door.

Scaling When You Need To Is Easier Than You Think

The good news is that scaling isn’t as hard as it used to be. Cloud platforms like AWS, Google Cloud, and Microsoft Azure make it easier than ever to add resources when you need them. You don’t need to be ready for millions of users from the start because modern infrastructure can scale up when the time comes.

When you hit that growth spurt, you’ll have tools available to scale quickly. Until then, keep your setup simple and cost-effective.

User Experience Matters More Than Scale

No one’s going to care how scalable your app is if it’s not enjoyable to use. If your early users are running into bugs, confusing interfaces, or missing features, it won’t matter how many servers you’ve got ready to handle millions more.

Your top priority right now should be creating a product that people love. The smoother and more enjoyable their experience, the more likely they are to stick around—and tell others about it. Get the basics right first, and worry about scale later.

In Summary: Build for Now, Not for “Someday”

When you’re just starting out, it’s tempting to prepare for a massive influx of users. But designing for scale when you’re still trying to get your first 100 users is overkill. It wastes time, money, and energy that could be better spent on improving your product and growing your user base.

Right now, your focus should be on creating something people want, shipping quickly, and learning from your users. If millions of users come down the line, you’ll be ready for them—but you don’t need to be ready today.

Build for the present, and let the future take care of itself when it arrives.

Why Copilot is Making Programmers Worse at Programming

Wed, 11 Sep 2024 11:47:58 +0100

Over the past few years, the evolution of AI-driven tools like GitHub’s Copilot and other large language models (LLMs) has promised to revolutionise programming. By leveraging deep learning, these tools can generate code, suggest solutions, and even troubleshoot issues in real-time, saving developers hours of work. While these tools have obvious benefits in terms of productivity, there’s a growing concern that they may also have unintended consequences on the quality and skillset of programmers.

Erosion of Core Programming Skills

One of the most significant risks of relying on tools like Copilot is the gradual erosion of fundamental programming skills. In the past, learning to code involved hands-on problem-solving, debugging, and a deep understanding of how code works at various levels—from algorithms to low-level implementation details.

AI assistants, while useful, often allow developers to bypass these steps. For instance, rather than deeply understanding the underlying structure of algorithms or learning how to write efficient loops and recursion, programmers can now just accept auto-generated code snippets. Over time, this could lead to developers who can’t effectively solve problems without an AI’s assistance because they never fully developed the problem-solving and critical-thinking skills necessary for programming.

Over-Reliance on Auto-Generated Code

With tools like Copilot, developers can quickly produce working code without fully understanding its mechanics. This leads to what’s known as “code dependency”, where developers lean too heavily on AI-generated solutions without checking for correctness, efficiency, or maintainability.

One key issue with auto-generated code is that it may not always be the optimal solution for a specific problem. Without proper vetting, programmers might accept inefficient, buggy, or insecure code that works at first glance but causes problems in the long run. This reliance reduces the incentive to refactor or even review the code, which could harm the codebase and team productivity over time.

Lack of Ownership and Responsibility

AI-assisted code generation can lead to a phenomenon where developers become detached from the code they “write”. When a developer writes every line of code manually, they take full responsibility for its behaviour, whether it’s functional, secure, or efficient. In contrast, when AI generates significant portions of code, it’s easy to shift that sense of responsibility onto the AI assistant.

This lack of ownership can make developers complacent, thinking, “The AI generated it, so it must be correct”. But AI-generated code isn’t immune to errors, bugs, or even security vulnerabilities. Ultimately, it’s the developer’s job to review, understand, and refine the code, but with the convenience of Copilot, that diligence might fade.

Reduced Learning Opportunities

One of the most crucial aspects of becoming a great programmer is the continuous learning process. Every bug encountered, every design decision made, and every algorithm researched is an opportunity to learn something new. However, by providing quick solutions, Copilot and other LLMs may shortcut the learning process, giving developers answers without requiring them to dig deeper into why certain solutions work or don’t work.

When a tool hands you the solution immediately, you’re less likely to seek alternative approaches, experiment with different methods, or fully understand the trade-offs of different implementations. This convenience, while beneficial in the short term, reduces the number of learning experiences that contribute to long-term skill development.

Narrowed Creative Thinking

Programming is as much about creativity as it is about logic. A skilled programmer can approach a problem from multiple angles and come up with a variety of solutions, weighing the pros and cons of each. By offering suggestions that are often based on existing code or patterns, AI-driven tools can limit a developer’s exploration of novel approaches or innovative solutions.

While Copilot can suggest “what works”, it may also promote more conventional or popular patterns at the expense of encouraging out-of-the-box thinking. The fear is that AI tools might cause programming to become a more mechanical process of accepting suggestions rather than a creative pursuit that pushes boundaries.

Dependency on Proprietary Tools

Another downside of AI-driven tools is the dependency they create on proprietary platforms like GitHub Copilot. When developers start using these tools, they become increasingly reliant on them to generate, troubleshoot, or optimise their code. This creates a problem when the tools fail, change their terms of service, or become too expensive.

Additionally, this dependency on AI tools can isolate developers from broader programming communities and open-source tools that encourage peer collaboration and knowledge sharing, further hindering the growth of their skills.

False Sense of Expertise

Perhaps one of the most concerning effects of AI code generation is that it can create a false sense of expertise among developers. A developer might feel proficient in programming because they can quickly generate working code with the help of Copilot, even if they don’t fully understand the code.

This can be particularly dangerous when developers move into more complex areas of software engineering, like performance optimization, concurrency, or security, where a deeper understanding of the code is critical. Without the foundational knowledge, developers can make mistakes that are costly in both time and money.

In Short

If you as the developer do not understand the code, do not understand how you got to where you are, do not understand how to solve the problem yourself. Copying and pasting code from a LLM, and being spoon fed the answer, is not going to make you a better programmer. Its going to make you reliant on the robot, and you will never be able to do anything that the robot cant already do.

Five Reasons Visual Studio is Better than Rider

Wed, 11 Sep 2024 10:57:38 +0100

JetBrains Rider has garnered attention as a modern, cross-platform IDE, especially for .NET developers. However, Visual Studio remains the reigning heavyweight in the development world, thanks to years of evolution and refinement. While Rider offers impressive features, there are still several areas where Visual Studio shines brighter. Here are five reasons why Visual Studio is better than Rider.

Comprehensive Microsoft Ecosystem Integration

Visual Studio is deeply integrated into the Microsoft ecosystem, making it the default choice for developers working with Microsoft technologies like .NET, Azure, and SQL Server. It offers out-of-the-box features and first-class support for tools such as Azure DevOps, Azure Functions, and Entity Framework, with easy configuration and deployment options.

While Rider offers solid support for the .NET ecosystem, Visual Studio’s native integration with Microsoft’s cloud and enterprise solutions makes it a one-stop shop for developers working in the Microsoft stack. Whether you need to deploy to Azure, use Microsoft-specific libraries, or configure cloud services, Visual Studio’s deep integration gives it a significant edge.

Powerful Debugging Tools

Visual Studio has some of the best debugging tools in the industry. It provides advanced features like Edit and Continue, Live Unit Testing, and IntelliTrace (for historical debugging), which help developers diagnose and fix issues more efficiently.

While Rider has strong debugging capabilities, it doesn’t quite match Visual Studio’s level of depth, especially when it comes to enterprise-level applications. IntelliTrace, for instance, allows developers to step back through time during debugging sessions, making it easier to pinpoint and solve complex issues. This feature is particularly valuable for debugging large applications with many moving parts, where standard breakpoints and stepping through code aren’t enough.

Comprehensive Support for GUI-Based Development

For developers working on Windows desktop applications, especially using technologies like WPF, Windows Forms, or UWP, Visual Studio provides superior support with its drag-and-drop designers and rich tooling for building GUI applications. The visual designers for XAML and WinForms allow for rapid prototyping, with a real-time preview of the UI as it’s being built.

While Rider offers basic support for WPF and other desktop frameworks, its GUI development tools are not as mature or fully featured as Visual Studio’s. The designer experience in Visual Studio is a major advantage for developers building desktop apps that require a lot of UI work.

More Mature Ecosystem and Extensions

Visual Studio has a massive and mature ecosystem of extensions available through the Visual Studio Marketplace. Whether you need tools for version control, database management, or third-party integrations, you’ll find a wide variety of well-supported plugins. Popular tools like CodeRush, Visual Assist, and SpecFlow are readily available and often offer better integration with Visual Studio than with Rider.

Rider has its own plugin marketplace, but it’s smaller in scale and doesn’t yet offer the same variety or depth of support that Visual Studio does. For developers who rely heavily on custom tooling and extensions to enhance their workflow, Visual Studio remains the more versatile platform.

Enterprise Features and Licensing

Visual Studio provides enterprise-grade features, particularly in the Visual Studio Enterprise edition. Features like Live Dependency Validation, Code Map, and Architectural Layer Diagrams are invaluable in large-scale enterprise environments. These tools allow teams to visualize complex project dependencies, validate architectural decisions, and ensure code quality at scale.

Rider’s offering is more focused on small to medium-sized teams, and while it includes many high-quality features for individual developers, it lacks some of the comprehensive enterprise tools available in Visual Studio. Additionally, Visual Studio’s enterprise licensing model provides extensive support and services for large organizations, making it an ideal choice for mission-critical applications in business environments.

Conclusion

While Rider is an excellent alternative IDE, Visual Studio remains the leader in several key areas. Its deep integration with the Microsoft ecosystem, advanced debugging tools, superior GUI development features, robust extension marketplace, and enterprise-focused features make it a powerhouse for developers working on .NET, cloud services, or large-scale enterprise applications. For many developers, especially those heavily invested in Microsoft technologies, Visual Studio is still the IDE of choice.

Five Reasons Rider is Better than Visual Studio

Wed, 11 Sep 2024 10:57:17 +0100

When it comes to .NET development, Visual Studio has long been the go-to integrated development environment (IDE). However, JetBrains' Rider has emerged as a serious competitor, offering a fresh alternative with features that many developers now prefer. While both are powerful tools, here are five reasons why Rider is considered better than Visual Studio for many developers.

Cross-Platform Support

One of Rider’s most significant advantages is its cross-platform compatibility. Rider runs smoothly on Windows, macOS, and Linux, providing a consistent development experience across different operating systems. This is a game-changer for developers who prefer using macOS or Linux for development but need access to .NET technologies, which traditionally were more Windows-centric.

Visual Studio, on the other hand, is largely limited to Windows. While Visual Studio for Mac exists, it lags behind in features and performance compared to its Windows counterpart, making Rider the superior option for cross-platform .NET development.

Faster Performance

Rider is widely praised for its speed and responsiveness. Built on the IntelliJ platform (the same engine powering JetBrains’ other IDEs like IntelliJ IDEA), Rider is optimized to handle large projects with ease. It doesn’t suffer from the sluggishness or memory bloat often associated with Visual Studio, particularly in resource-heavy projects.

The performance gap is even more noticeable when working with solutions that contain multiple projects. Rider’s ability to index files efficiently and provide fast code navigation and refactoring tools allows developers to work without interruptions.

Advanced Code Analysis and Refactoring

JetBrains is known for its superior code analysis tools, and Rider continues this tradition. It provides real-time code inspections, detecting issues as you type, and offering intelligent suggestions for code improvements. Rider integrates tools from ReSharper (JetBrains’ popular Visual Studio extension), giving you access to an extensive set of refactoring and code transformation tools right out of the box.

In Visual Studio, you typically need to install ReSharper as an add-on, which can significantly slow down the IDE. With Rider, ReSharper’s capabilities are built-in and optimized, providing advanced refactorings, code fixes, and insights without performance penalties.

Unified Experience for Multiple Languages

Rider is more than just a .NET IDE; it’s also a robust tool for polyglot developers. It supports a wide variety of languages beyond C#, such as JavaScript, TypeScript, HTML, CSS, and more. This makes it an excellent choice for full-stack developers working across the .NET ecosystem and front-end technologies.

In contrast, Visual Studio often requires separate extensions for working with different languages, and its support can be inconsistent or not as smooth as in Rider. Rider’s seamless integration of multiple language support under one roof makes for a streamlined, unified development experience.

Comprehensive Git Integration

Rider excels in its version control integration, particularly with Git. Its user interface for Git actions is intuitive, allowing you to stage, commit, rebase, and merge changes directly within the IDE with ease. Rider’s Git tool window provides a clear visual representation of commits, branches, and diffs, which helps developers better understand their code history and manage branches effectively.

Visual Studio’s Git support has improved over time, but it still lacks the depth and usability of Rider’s implementation. Rider’s superior merge conflict resolution, interactive rebase tools, and comprehensive commit history make it a better choice for developers who heavily rely on Git.

Conclusion

Both Rider and Visual Studio are excellent IDEs, but Rider’s cross-platform support, performance, advanced code analysis, multi-language capabilities, and superior Git integration make it a compelling alternative to Visual Studio, especially for developers working on complex .NET projects or those who want a more versatile, streamlined development environment. Whether you’re a long-time .NET developer or exploring new tools, Rider is definitely worth a look.

The Single Best and Worst Things About Popular Programming Languages

Wed, 11 Sep 2024 10:37:49 +0100

I use a lot of programming languages, I use them in different ways for different things because they are tools to do a job, just like a hammer is a tool to hammer in nails and a screwdriver (shockingly) drives screws… And while you can hammer in nails with a screwdriver, and you can drive screws with a hammer… They are not the best tools for those jobs.

So lets have a look at what jobs that some given languages, are good at and what they are bad at…

C

Best Thing: Low-Level Control
- C provides an unparalleled level of control over system resources like memory and hardware. This is why it’s the foundation of operating systems, embedded systems, and high-performance applications.
Worst Thing: Manual Memory Management
- The flip side of C’s low-level control is that it requires the programmer to manage memory manually. This can lead to errors like memory leaks and segmentation faults, which can be tricky to debug.

C++

Best Thing: Object-Oriented with High Performance
- C++ combines the power of C with object-oriented features, making it suitable for high-performance applications that still need abstractions like classes and inheritance.
Worst Thing: Complexity
- C++ is notoriously complex, with a vast array of features, from multiple inheritance to template metaprogramming, which can be difficult to learn and prone to misuse.

C#

Best Thing: Integrated Development with .NET
- C# is tightly integrated with Microsoft’s .NET ecosystem, making it easy to develop cross-platform applications, particularly desktop and web apps, with powerful development tools like Visual Studio.
Worst Thing: Platform Dependency (Historically)
- While cross-platform support has improved with .NET Core and later versions, C# was long seen as a Microsoft-centric language, limiting its appeal to developers working outside the Windows ecosystem.

Java

Best Thing: Write Once, Run Anywhere
- Java’s promise of platform independence through the Java Virtual Machine (JVM) allows code to run on any system that has a JVM, making it a top choice for enterprise applications.
Worst Thing: Verbose Syntax
- Java’s strict object-oriented nature and requirement for boilerplate code, like getters and setters, make it more verbose than other languages, leading to more typing and less concise code.

JavaScript

Best Thing: Ubiquity in Web Development
- JavaScript is the only programming language natively supported by all web browsers, making it indispensable for front-end web development. Its versatility with frameworks like Node.js also extends its reach to the server side.
Worst Thing: Inconsistent Behavior
- JavaScript’s quirks, such as type coercion and confusing scoping rules, often result in unexpected behavior, leading to frustration, especially for beginners.

Rust

Best Thing: Memory Safety Without a Garbage Collector
- Rust’s unique ownership model ensures memory safety and prevents common bugs like null pointer dereferencing or data races, all without needing a garbage collector.
Worst Thing: Steep Learning Curve
- Rust’s novel concepts, particularly around ownership and lifetimes, can be challenging to grasp, even for experienced developers coming from other languages.

Python

Best Thing: Readability and Simplicity
- Python’s clean and human-readable syntax makes it an ideal language for beginners, while its vast libraries and frameworks make it powerful enough for professional use in data science, web development, and automation.
Worst Thing: Performance
- Python is an interpreted language and tends to be slower than compiled languages like C or Go, making it less ideal for performance-critical applications.

PHP

Best Thing: Web Development Simplicity
- PHP is designed for the web, and its tight integration with HTML makes it extremely simple to create dynamic web pages. This makes it a popular choice for content management systems like WordPress.
Worst Thing: Inconsistent Design
- PHP has evolved organically, leading to inconsistent naming conventions, inconsistent function arguments, and a general feeling of “messiness” in larger projects.

Ruby

Best Thing: Elegant Syntax
- Ruby’s principle of “optimizing for programmer happiness” is reflected in its elegant and expressive syntax, making it a joy to read and write, especially when using frameworks like Ruby on Rails.
Worst Thing: Performance Issues
- Ruby can be slow in comparison to languages like Python or Java, especially when it comes to CPU-bound operations, which may limit its use in high-performance applications.

Swift

Best Thing: Modern Language for Apple Ecosystem
- Swift was designed to be fast, safe, and expressive, and it has become the go-to language for developing iOS and macOS apps. Its syntax is concise yet powerful, which improves developer productivity.
Worst Thing: Apple-Only Focus
- Despite its technical merits, Swift’s primary use case is still within the Apple ecosystem, limiting its reach for developers who aren’t working on Apple platforms.

Go

Best Thing: Concurrency Support
- Go was designed with concurrency in mind, and its goroutines provide a simple yet powerful way to handle multiple tasks simultaneously, making it ideal for distributed systems and network services.
Worst Thing: Limited Language Features
- While Go’s simplicity is a strength, some developers find it too minimalistic, lacking features like generics (which were added only in later versions) and comprehensive error handling patterns.

Kotlin

Best Thing: Interoperability with Java
- Kotlin’s seamless interoperability with Java, combined with modern language features like null safety and extension functions, make it an ideal choice for Android development and projects with existing Java codebases.
Worst Thing: Limited Ecosystem Outside the JVM
- Although Kotlin has been growing in popularity, especially for Android development, its ecosystem outside of JVM-related applications is still limited compared to more established languages.

Assembly

Best Thing: Maximum Control Over Hardware
- Writing in Assembly allows developers to control the hardware at the instruction level, making it essential for developing highly optimized, low-level software like drivers and bootloaders.
Worst Thing: Complexity and Readability
- Assembly is difficult to write and even harder to read. It requires a deep understanding of the underlying hardware and is impractical for most modern software development tasks.

Objective-C

Best Thing: Mature Language for macOS and iOS
- Objective-C has been the backbone of Apple development for decades, and it has a rich ecosystem of libraries, frameworks, and tools designed for macOS and iOS applications.
Worst Thing: Verbose Syntax
- Objective-C’s syntax is notoriously verbose, particularly when compared to newer languages like Swift. This can make code harder to read and write, slowing down development.

This is by no means an exhaustive list, nor is it a concrete guide of “this is how you should do things”, this is just what I have found over the years and what I personally have found to be the best and worst parts of these languages and what they are good at, and not good at. What languages do you use, and what do you think they are or are not good at?

HTTP Server Tutorial in Rust

Tue, 23 Jul 2024 22:11:39 +0100

In the modern web landscape, understanding how HTTP servers work under the hood can be incredibly empowering. While there are many frameworks and libraries available that abstract away the complexities of building an HTTP server, sometimes it’s valuable to get back to basics and see how things work from the ground up.

In this tutorial, we will guide you through building a simple HTTP server in Rust using only the standard library, without relying on any external crates. This will give you a solid understanding of network programming in Rust and a foundation you can build on to create more complex servers in the future.

In Rust, the main function is the entry point of any executable program. Here’s the complete main function from our server code:

fn main() {
let listener = TcpListener::bind("127.0.0.1:3000").unwrap();
println!("Listening on port 3000...");
for stream in listener.incoming() {
match stream {
Ok(stream) => {
thread::spawn(move || {
handle_client(stream);
});
}
Err(e) => {
eprintln!("Error: {}", e);
}
}
}
}

Step-by-Step Breakdown

Binding to an Address
```
let listener = TcpListener::bind("127.0.0.1:3000").unwrap();
```
- TcpListener::bind: This function binds the server to the specified IP address and port. Here, 127.0.0.1:3000 means the server will listen on localhost, port 3000.
- unwrap(): This function is used for error handling. It will panic if binding fails. In a production server, you might want to handle this error more gracefully.
Logging Server Status
```
println!("Listening on port 3000...");
```
- This line prints a message to the console, indicating that the server is up and running and listening on port 3000.
Accepting Incoming Connections
```
for stream in listener.incoming() {
match stream {
Ok(stream) => {
thread::spawn(move || {
handle_client(stream);
});
}
Err(e) => {
eprintln!("Error: {}", e);
}
}
}
```
- listener.incoming(): This method returns an iterator over incoming connections. It will block until a client connects.
- for stream in listener.incoming(): This loop iterates over each incoming connection. For each connection, stream is a TcpStream instance.
Handling Each Connection
```
match stream {
Ok(stream) => {
thread::spawn(move || {
handle_client(stream);
});
}
Err(e) => {
eprintln!("Error: {}", e);
}
}
```
- match stream: This pattern matches the result of listener.incoming(). It handles two cases:
  - Ok(stream): If a connection is successfully established, stream is a TcpStream object representing the connection.
    - thread::spawn(move || { handle_client(stream); }): This spawns a new thread to handle the client connection. The move keyword moves stream into the closure, allowing it to be accessed within the thread.
  - Err(e): If an error occurs while accepting a connection, it prints the error message to stderr.

Example of Handling a Client Connection

Inside the thread::spawn closure, we call handle_client(stream):

thread::spawn(move || {
handle_client(stream);
});

This line starts a new thread and calls the handle_client function, passing the stream as an argument. Here’s what handle_client looks like:

fn handle_client(mut stream: TcpStream) {
let mut buffer = [0; 1024];
if let Ok(_) = stream.read(&mut buffer) {
let response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello, World!";
let _ = stream.write(response.as_bytes());
let _ = stream.flush();
}
}

Reading from the Stream: stream.read(&mut buffer) reads the incoming request into the buffer.
Constructing the Response: We create a simple HTTP response as a string.
Writing the Response: stream.write(response.as_bytes()) sends the response back to the client, and stream.flush() ensures all data is sent.

Conclusion

The main function is the heart of our server, managing incoming connections and delegating client handling to separate threads. This modular approach ensures that the server remains responsive and can handle multiple clients simultaneously.

Feel free to ask if you have any specific questions or need further clarifications on any part of the code!

Why GraphQL is Better Than Basic REST and SOAP APIs

Tue, 04 Jun 2024 14:35:03 +0100

SOAP and REST have been the dominant protocols for years. However, GraphQL has emerged in the last few years as a powerful alternative, offering numerous advantages over its predecessors. In this article, we’ll explore why GraphQL is often considered better than basic REST and SOAP APIs, and why you might want to consider it for your next project.

Understanding the Basics

SOAP

SOAP (Simple Object Access Protocol) is a protocol for exchanging structured information in the implementation of web services. It relies on XML-based messaging and is known for its strong standards and security features. SOAP is often used in enterprise-level applications where reliability and security are paramount.

REST

REST (Representational State Transfer) is an architectural style that uses standard HTTP methods and is known for its simplicity and ease of use. REST APIs typically exchange data in JSON format and are widely used for web and mobile applications due to their flexibility and ease of integration.

GraphQL

GraphQL, developed by Facebook in 2012 and released publicly in 2015, is a query language for your API, and a server-side runtime for executing queries by using a type system you define for your data. It enables clients to request exactly the data they need, nothing more, and nothing less.

Why GraphQL is Better Than REST and SOAP

1. Precise Data Fetching

One of the most significant advantages of GraphQL is its ability to allow clients to request exactly the data they need. This contrasts sharply with REST, where you might need multiple endpoints to gather related data, often leading to over-fetching or under-fetching of data.

Example: In REST, to get user information along with their posts, you might have to hit two endpoints:

GET /users/1
GET /users/1/posts

In GraphQL, a single query can fetch exactly what’s needed:

{
user(id: 1) {
name
posts {
title
}
}
}

2. Strongly Typed Schema

GraphQL APIs are defined by a schema, which is a strong, self-documenting contract between the server and the client. This schema is introspectable, allowing developers to understand the structure of the API without external documentation. REST and SOAP do not enforce a single way to define and discover the API’s schema, leading to inconsistencies and increased reliance on external documentation.

3. Single Endpoint

GraphQL operates on a single endpoint, which simplifies the API structure and reduces complexity in routing. In contrast, REST typically involves multiple endpoints for different resources, which can become cumbersome to manage as an application grows.

Example: A REST API might have the following endpoints:

GET /users
GET /posts
GET /comments

A GraphQL API would have a single endpoint, e.g., /graphql, where all queries and mutations are directed.

4. Reduced Overhead

GraphQL reduces the number of HTTP requests needed to fetch related data. This is particularly beneficial for applications with complex relationships and nested data structures. By reducing the number of round-trips between the client and server, GraphQL can lead to improved performance and a better user experience.

5. Better Developer Experience

GraphQL’s introspection capabilities allow for powerful development tools, such as GraphiQL, an in-browser IDE for exploring GraphQL APIs. These tools can significantly enhance the developer experience by providing real-time feedback and auto-completion.

6. Evolution Without Versioning

GraphQL allows APIs to evolve without the need for versioning. New fields and types can be added to the GraphQL schema without impacting existing queries. In contrast, REST APIs often rely on versioning to manage changes, which can lead to fragmentation and increased maintenance overhead.

Example: Adding a new field in REST might involve creating a new versioned endpoint:

GET /v2/users/1

In GraphQL, you simply add the new field to the schema, and clients can start querying it immediately.

Use Cases Where GraphQL Excels

Mobile and Single-Page Applications: These applications often require efficient data fetching to improve performance and user experience.
Complex Systems and Microservices: GraphQL can serve as an aggregation layer, fetching data from multiple sources and presenting it through a unified API.
APIs with Rapidly Changing Requirements: The flexibility of GraphQL allows for quick adaptation without the need for extensive versioning and maintenance.

Conclusion

While REST and SOAP have their strengths and are still widely used, GraphQL offers a modern approach that addresses many of the pain points associated with these older technologies. Its ability to fetch precise data, introspectable schema, single endpoint architecture, reduced overhead, enhanced developer experience, and smooth evolution without versioning make it a compelling choice for many applications. If you’re looking to build an efficient, scalable, and developer-friendly API, GraphQL is certainly worth considering.

Save KSP2 - An Open Letter to Take-Two and CEO Strauss Zelnick

Sat, 01 Jun 2024 23:03:32 +0100

Dear Mr. Zelnick,

I hope this letter finds you well. I am writing to you as a dedicated member of the Kerbal Space Program (KSP) community, a group that shares an unparalleled passion for space exploration and engineering, and whose enthusiasm for the franchise has only grown since the original game’s release. I am deeply concerned about the recent decision to cancel Kerbal Space Program 2 (KSP2), a game with enormous potential that deserves another chance to succeed under the right circumstances.

Kerbal Space Program has cultivated a large and dedicated community that spans across all ages, particularly inspiring young minds to delve into the wonders of space travel and engineering. The game’s unique blend of education and entertainment has not only provided countless hours of enjoyment but has also sparked an interest in STEM fields for many children and young adults. The cancellation of KSP2 is not just a loss for the fans but a missed opportunity to continue fostering this educational impact.

The challenges KSP2 has faced since its announcement can largely be attributed to mismanagement by Take-Two and Private Division. Despite these setbacks, the core vision and potential of the game remain intact. The issues are not with the concept or the community’s enthusiasm but with the execution and oversight of the project. With the right management and development team, KSP2 can overcome its current hurdles and achieve the greatness that the community knows it is capable of.

Reconsidering the cancellation of KSP2 and investing in proper management and resources will not only save the game but also reinforce Take-Two’s commitment to its community and the educational value it brings. A revitalized KSP2 can reignite the interest of the next generation in space exploration and engineering, aligning perfectly with the growing global focus on these fields. The benefits of nurturing such interests extend beyond gaming, potentially leading to future innovations and advancements as inspired players pursue careers in STEM disciplines.

The KSP community stands ready to support and contribute to the game’s success. Our passion and dedication are unwavering, and we believe that with the right leadership, KSP2 can become a landmark title that continues to inspire and educate.

I kindly urge you to reconsider the decision to cancel Kerbal Space Program 2. Invest in the right team and management, and you will see not only a successful game but also a legacy that inspires future generations.

Thank you for your time and consideration.

Sincerely,

The KSP Community

I would urge all members of the KSP Community to send this to T2 CEO at the following address:

Mr. Strauss Zelnick
CEO, Take-Two Interactive
110 West 44th Street
New York, NY 10036

or via email to strauss.zelnick@take2games.com

Why is AI Such a Polarising Subject? Does it Change Everything? Or Nothing?

Wed, 15 May 2024 11:45:14 +0100

AI seems to be a very polarising subject. On the whole, most people seem to be in one of two camps: “AI IS THE FUTURE OF EVERYTHING!" or “AI IS TERRIBLE AT EVERYTHING! IT’S NOT INTELLIGENT AT ALL” (caps intended).

The polarisation around AI stems from multiple factors, including misunderstandings, exaggerated expectations, fear of the unknown, and legitimate concerns about the implications of AI on society.

Exaggerated Expectations: The media often sensationalises AI advancements, describing them as either utopian solutions to all our problems or dystopian threats to humanity. This leads to unrealistic expectations on one hand and unwarranted fear on the other.
Misunderstandings about AI: Many people have a limited understanding of what AI actually is and what it can do. This lack of understanding can lead to either overestimating AI capabilities (thinking it can do everything a human can) or underestimating them (believing it’s incapable of true intelligence).
Fear of Job Displacement: Automation powered by AI can have the potential to disrupt industries and replace certain types of jobs. This fear of job loss contributes to the negative perception of AI, especially among those who feel threatened by it.
Ethical Concerns: AI raises important ethical questions, such as bias in algorithms, invasion of privacy, and the potential for misuse (e.g., in surveillance or autonomous weapons). These concerns rightly lead to skepticism and criticism of AI development and deployment.
Cultural and Philosophical Perspectives: Some individuals have philosophical or cultural beliefs that shape their views on AI. For example, those who view human intelligence as unique and sacred may be more skeptical of AI’s capabilities, while others who see technology as the path to progress may be more optimistic.
Experience and Exposure: Personal experiences with AI technology can greatly influence one’s opinion. Positive experiences may lead to enthusiasm and optimism, while negative experiences can breed skepticism and distrust.
Media Portrayal: Depictions of AI in movies, literature, and other forms of media often reinforce stereotypes and misconceptions, shaping public perception in the process.

In reality, AI is neither the savior of humanity nor its downfall. It’s a tool, like a hammer or like any other technology, with the potential for both positive and negative impacts depending on how it’s developed and used. And like a hammer, not every problem is a nail, and not every problem requires AI, and problems that are nails, may or may not require the AI hammer. Acknowledging and accepting this is crucial for having productive discussions about AI and its role in our future.

PirateSoftware is a Hypocrite - Helldivers 2 and Security

Fri, 03 May 2024 10:14:38 +0100

PirateSoftware on Twitch took a stand against kernel-level anti-cheat in Helldivers 2 but found a workaround by buying a multi-thousand dollar second PC and plays it on there as a way of pretending they have “worked around” the kernel-level anti-cheat requirement. They are now pretending that the PSN account requirement for Helldivers, which was a requirement from the start (but not enforced), is a step too far because of “security”.

He tried to justify the second PC by being “a security specialist” and “I didn’t invite it onto my system”, but the problem is, by buying the game and installing it, and playing the game, you are inviting it onto your system. His stance against the game would have led many to not play it, or many to also attempt to buy second systems they didn’t need.

He played the game for many hours on stream, gaining quite a lot of ad revenue and bit/subscriber revenue because of the game and its hype. All the time, continuing his fake protest against kernel-level anti-cheat.

Today, Sony announced that the PSN account requirement would start to be enforced. The same PSN account requirement was required from the start but was not enforced due to technical issues at Sony. Sony stated that the requirement would be enforced in the future.

PirateSoftware played anyway because it benefited them to play Helldivers on stream. Now that benefit has expired, because the hype has worn out, his morals have snapped back and PirateSoftware is now taking a stand against the game.

PirateSoftware should either have taken a stand from the start and not played the game at all, or admit that they are doing what is best for themselves and their stream since being honest with the community is the best course of action.

Stop Using string.ToLowerInvariant() to Compare Strings. InvariantCulture Comparisons are Slow

Thu, 07 Mar 2024 11:29:49 +0000

A lot of people use ToLower() or ToLowerInvariant() to normalise their strings before comparing them with ==, STOP IT.

This is very slow, and while that may not matter for 1 or 2 string comparasons, it mounts up in large projects.

While there is a very small use case for using Invariant Culture, unless you are absolutely certain that you need it, and why you need it, then you do not need it.

These tests in github aim to show what we should be using instead.

Each test was ran 100,000,000 times, which is a realistic number of records that could be compared in a loop.

Test	Time in ms
ToLowerInvariant	2667 ms
ToUpperInvariant	2302 ms
DOUBLE ToLowerInvariant	3864 ms
Equals (NoOptions) (as a control test)	426 ms
Equals (InvariantCultureIgnoreCase)	14891 ms
Equals (CurrentCultureIgnoreCase)	14605 ms
Equals (OrdinalIgnoreCase)	1168 ms

As you can see, Equals with OrdinalIgnoreCase is an order of magnitude faster than InvariantCultureIgnoreCase, and about twice as fast (half as slow) as ToLowerInvariant. Stop using Invariant unless you absolutely understand your use case for it.

Respecting the Clock: Unveiling the Time-Wasting Pitfalls in Professional Software Development

Wed, 10 Jan 2024 11:00:47 +0000

In software development, where time is very expensive and efficiency is paramount, it’s crucial to recognize and address common practices that can lead to unnecessary time wastage. This article aims to shed light on the professional nature of software developers, emphasizing the need for respectful and time-efficient communication within established software companies.

Professionals, Not Children

The first and foremost point to establish is the professionalism of those working in software development, particularly in well-established companies. These individuals are seasoned experts, not children needing hand-holding. Recognizing their expertise and treating them accordingly is vital for fostering a productive work environment.

The High Cost of Time

Time is a valuable resource, especially for well-paid professionals in the software industry. Acknowledging the expense of their time is crucial in ensuring that every meeting, interaction, and decision is optimized for efficiency.

The Sugar-Coated Time Sink

Meetings laden with unnecessary sugar coating not only distract from the main points but also waste precious time. Striking a balance between diplomacy and directness is essential in ensuring that communication is both respectful and time-efficient.

Stories vs. Succinctness

While storytelling can be a powerful communication tool, there’s a fine line between engaging narratives and time-consuming tangents. Meetings that meander through lengthy stories before getting to the point can become significant time-wasters, hindering productivity.

Email-Worthy Matters

Identifying when a meeting could have been an email is crucial to preventing time wastage. Respect for professionals' time involves recognizing when face-to-face discussions are truly necessary and when information could be disseminated more efficiently through written communication.

Selling without Overselling

Product owners attempting to sell a product to their own staff must strike a delicate balance. Glossing over downsides and exaggerating benefits can lead to disillusionment among professionals who can see through the smoke and mirrors. Honesty and transparency are key to maintaining trust.

Evidence Over Knee-Jerk Defense

In the realm of software development, evidence-based decision-making is paramount. Knee-jerk defending of a poor approach, even when faced with compelling evidence against it, only serves to hinder progress. Encouraging an open-minded and evidence-driven culture is vital for the continual improvement of processes and methodologies.

In conclusion, recognizing the professionalism, time value, and expertise of software developers in established companies is the cornerstone of efficient collaboration. By eliminating time-wasting practices such as sugar coating, meandering meetings, and ineffective communication, the software development industry can strive for increased productivity and continual improvement.

Why are Women so Underrepresented in Software Development?

Thu, 30 Nov 2023 09:33:04 +0000

I have to preface this with “I am a man, not a woman, this is an opinion based on what I have seen in 20+ years of working as a software developer in many different companies”.

With that, software development has a noticeable gender gap, with women underrepresented in comparison to their male counterparts. This disparity is a multifaceted issue with roots in societal, educational, and workplace factors. In this article, we’ll explore the various reasons behind the underrepresentation of women in programming jobs and discuss potential solutions to bridge this gap.

Societal Stereotypes

From a young age, societal stereotypes can shape perceptions of gender roles, influencing career choices. Stereotypes that suggest programming is a male-dominated field may discourage girls from pursuing interests in technology. Challenging and reshaping these stereotypes is crucial for fostering inclusivity.

A possible “solution” (that would require a cultural shift) to this is challenging stereotypes through educational initiatives and awareness campaigns that showcase successful women in programming. Encourage media, schools, and parents to provide equal exposure to technology-related activities for both girls and boys.

Educational Disparities

Access to quality computer science education is essential for nurturing an interest in programming. Disparities in educational opportunities and experiences can limit girls' exposure to coding and technology, hindering their path to programming careers. Efforts to provide equal access and encouragement in STEM education are key to addressing this issue.

Again, combatting this would require a cultural and politically driven shift as we would need to implement policies that promote equal access to computer science education for all students. Create mentorship programs and extracurricular activities that specifically target and support girls interested in coding and technology.

Lack of Role Models

Despite some of the most prominent programmers from history being women, I believe that the absence of visible female role models in programming can contribute to the underrepresentation of women. Highlighting successful women in the field can inspire and empower others, breaking down stereotypes and demonstrating that programming is a viable and rewarding career choice for women.

In school, everybody learns about Alan Turing, and maybe Charles Babbage, and are taught who Bill Gates is, but why do we not get taught about Ada Lovelace, Grace Hopper or Margaret Hamilton?

Workplace Culture

Creating an inclusive workplace culture is pivotal in attracting and retaining women in programming jobs. Companies must actively work to eliminate gender bias, promote diversity and inclusion, and foster an environment where all employees feel valued and respected.

This will only be solved with the points before this point being addressed, the more women that enter the workplace, the more that the culture will shift away from the “nerdy boys” stereotype of programming jobs, allowing the whole workplace culture to be more suitable for anybody.

Implicit Bias

Unconscious biases can influence hiring decisions and career advancement opportunities. Addressing implicit biases, both on an individual and organizational level, is crucial for ensuring fair and equal treatment in the recruitment process.

Work-Life Balance Challenges

Perceptions of programming jobs as demanding and incompatible with work-life balance can deter women, especially those concerned about balancing career and family responsibilities. Promoting flexible work arrangements and emphasizing the importance of work-life balance can make programming careers more accessible.

This was recently pushed dramatically in the correct direction with the huge shift towards “Work From Home” culture, that many software development jobs are keeping in place, which helps everybody, not just women.

Lack of Networking Opportunities

Networking plays a vital role in career advancement. Creating networking and mentorship opportunities specifically designed to support women in programming can help build connections and facilitate professional growth.

Unconscious Biases in Hiring

Examining and adjusting hiring practices is essential to eliminate biases that may inadvertently disadvantage women. Using gender-neutral language in job descriptions, broadening criteria, and ensuring diverse hiring panels can contribute to a more equitable hiring process.

Conclusion

Addressing the underrepresentation of women in programming requires a collective effort from educators, industry leaders, and policymakers. By challenging stereotypes, promoting diversity in education, creating inclusive workplace cultures, and addressing unconscious biases, we can pave the way for a more gender-balanced and thriving programming community. It’s time to break down barriers and ensure that women have equal opportunities to contribute their skills and innovation to the dynamic world of programming.

Whats New in ML.NET 3.0

Tue, 28 Nov 2023 09:23:19 +0000

ML.NET is an open-source, cross-platform machine learning framework for .NET developers, offering exciting capabilities in deep learning, data processing, and more. Given that Microsoft recently announced ML.NET 3.0, let’s take a closer look at what ML.NET 3.0 has in store.

Deep Learning Takes Center Stage

In ML.NET 3.0, deep learning scenarios have been significantly expanded. The framework now boasts new capabilities in Object Detection, Named Entity Recognition (NER), and Question Answering (QA). These advancements are made possible through seamless integrations with TorchSharp and ONNX models. The integration with LightGBM has also been updated to the latest version, ensuring that you’re on the cutting edge of deep learning possibilities.

Object Detection Unleashed

Object detection, a crucial aspect of computer vision, is now seamlessly integrated into ML.NET 3.0. This functionality allows for more granular image classification, locating and categorizing entities within images. Leveraging TorchSharp-powered Object Detection APIs, ML.NET enables you to work with the latest techniques from Microsoft Research, backed by a state-of-the-art Transformer-based neural network architecture.

// Sample code for Object Detection
var chain = new EstimatorChain<ITransformer>();
// ... (code for data processing and model training)
var metrics = ML.MulticlassClassification.EvaluateObjectDetection(
idv, idv.Schema[2], idv.Schema[boundingBoxColumnName], idv.Schema[predictedLabelColumnName],
idv.Schema[predictedBoundingBoxColumnName], idv.Schema[scoreColumnName]
);

Named Entity Recognition and Question Answering

Natural Language Processing (NLP) is a common need in software, and ML.NET 3.0 meets this demand head-on. NER and QA scenarios are unlocked in this release, building upon the existing TorchSharp RoBERTa text classification features introduced in ML.NET 2.0. The trainers for both NER and QA are bundled within the Microsoft.ML.TorchSharp 3.0.0 package.

// Sample code for QA trainer
var chain = new EstimatorChain<ITransformer>();
var estimatorQA = chain.Append(mlContext.MulticlassClassification.Trainers.QuestionAnswer(
// ... (parameters for QA training)
));
// Sample code for NER trainer
var estimatorNER = chain.Append(mlContext.Transforms.Conversion.MapValueToKey("Label", keyData))
.Append(mlContext.MulticlassClassification.Trainers.NameEntityRecognition(
// ... (parameters for NER training)
 ))
.Append(mlContext.Transforms.Conversion.MapKeyToValue(outputColumn));

Intel oneDAL Training Acceleration

ML.NET 3.0 introduces training hardware acceleration powered by Intel oneDAL (Intel oneAPI Data Analytics Library). This library optimizes data analysis by providing highly optimized algorithmic building blocks, utilizing SIMD extensions in 64-bit architectures found in both Intel and AMD CPUs.

Automated Machine Learning (AutoML) Empowerment

AutoML experiences in ML.NET get a boost in version 3.0. The AutoML Sweeper now supports Sentence Similarity, QA, and Object Detection. Continuous resource monitoring is introduced to control long-running experiments and avoid crashes.

DataFrame Revamped

The release includes a plethora of updates to DataFrame, enhancing its capabilities. These updates, contributed by the community, include support for IDataView <-> DataFrame conversions with String and VBuffer column types. Increased data storage capacity, recognition of Apache Arrow Date64 column data, and expanded data loading scenarios from and to SQL databases are some notable improvements.

Tensor Primitives Integration

ML.NET 3.0 seamlessly integrates with Tensor Primitives (System.Numerics.Tensors), introducing support for tensor operations and bringing about notable performance improvements. Benchmark results targeting .NET 8 showcase the efficiency gains achieved through this integration.

ML.NET 3.0 is a game-changer for .NET developers diving into machine learning. With enhanced deep learning capabilities, streamlined data processing, and integration with cutting-edge technologies, it opens up a world of possibilities. Whether you’re into computer vision, natural language processing, or automated machine learning, ML.NET 3.0 has something for everyone. Dive into the release notes for a comprehensive view of all the updates and start exploring the future of machine learning with ML.NET!

Mastering Backend Development in C#: 5 Essential Skills

Fri, 24 Nov 2023 21:15:20 +0000

Backend development in C# involves more than just writing code. To become a proficient backend developer, one must master a combination of programming language fundamentals and specific tools and frameworks. In this article, we’ll explore five essential skills that every backend C# developer should have, and we’ll delve into why each skill is crucial for success.

1. C# Language Proficiency

Generics:

Generics in C# provide a powerful way to create reusable and type-safe components. This is essential for writing flexible and maintainable code. By defining classes and methods with generics, developers can design components that work with a variety of data types, promoting code reusability.

LINQ (Language Integrated Query):

LINQ is a feature that allows developers to write queries directly within C# code. This not only simplifies the syntax but also enhances code readability. Proficiency in LINQ is crucial for efficient data manipulation, making it an indispensable skill for any C# developer.

Asynchronous Programming:

Asynchronous programming with async and await is a game-changer for backend developers. It allows for the creation of responsive applications by handling time-consuming operations, such as I/O tasks, without blocking the main thread. This skill is paramount for building scalable and high-performance systems.

2. ASP.NET Core

Middleware:

Middleware components in ASP.NET Core enable developers to modularize application logic. This promotes a separation of concerns, making the codebase more maintainable and extensible. Understanding how to leverage middleware is fundamental for crafting robust and scalable web applications.

Routing:

Efficient routing is the backbone of any web application. ASP.NET Core’s routing system directs incoming requests to the appropriate controllers and actions. Mastery of routing is crucial for building RESTful APIs and MVC applications, ensuring that requests are processed seamlessly.

Dependency Injection in ASP.NET Core:

ASP.NET Core comes with a built-in dependency injection container. Proficiency in dependency injection allows developers to manage dependencies, making their codebase more modular, testable, and easier to maintain. It’s a key aspect of building loosely coupled and scalable systems.

3. Entity Framework Core

Code-First Development:

Entity Framework Core supports a code-first approach, allowing developers to define data models in code. This approach aligns development with the codebase, making it easier to manage and version database schemas. Code-first development streamlines the database integration process.

Migrations:

Database schema evolution is a common challenge in software development. Entity Framework Core’s migration feature automates this process, making it easier to manage changes over time. Developers can create, apply, and roll back migrations, ensuring consistency between the application and the database.

Querying and CRUD Operations:

Entity Framework Core simplifies database interactions by providing a high-level abstraction for CRUD operations. Developers can focus on application logic rather than dealing with low-level database access. Proficiency in querying and CRUD operations is vital for efficient data management.

4. Dependency Injection

Constructor Injection:

Constructor injection is a fundamental principle of dependency injection. It promotes modularity and testability by explicitly declaring and injecting dependencies. This leads to code that is more transparent, maintainable, and easier to test.

Lifetime Management:

Understanding the lifetime of dependencies is crucial for managing resources effectively. ASP.NET Core’s dependency injection container offers different lifetimes (transient, scoped, singleton) for managing how instances of dependencies are created and disposed. Proper lifetime management ensures optimal resource usage.

5. RESTful API Design

HTTP Methods:

RESTful API design relies on proper usage of HTTP methods. Each method has a specific purpose (GET for retrieval, POST for creation, etc.), providing a standardized and intuitive way to perform operations on resources. Following RESTful principles improves the design and usability of APIs.

Status Codes:

HTTP status codes communicate the outcome of API requests. This allows clients to understand the success or failure of their actions. Clear and consistent use of status codes is essential for a positive user experience and effective error handling.

Versioning and Documentation:

API versioning allows for gradual updates and backward compatibility. Clear documentation is crucial for developers using the API, providing insights into endpoints, request/response formats, and authentication. Tools like Swagger/OpenAPI can assist in creating and maintaining comprehensive API documentation.

Conclusion

Mastering these five essential skills is key to becoming a successful backend C# developer. Proficiency in the C# language, ASP.NET Core, Entity Framework Core, dependency injection, and RESTful API design will empower you to build scalable, maintainable, and high-performance backend systems. Remember, continuous learning and staying updated with industry trends are vital for long-term success in the dynamic field of backend development. Happy coding!

.NET Chiseled Containers: A Revolution in Deployment Efficiency

Tue, 21 Nov 2023 15:02:35 +0000

In a groundbreaking announcement, Canonical and Microsoft have declared the general availability of “.NET Chiseled Ubuntu container images” for production use with .NET 6, 7, and 8. This release is the culmination of a year-long partnership and design collaboration between the two tech giants, aimed at optimizing containerized applications for size, security, and efficiency.

What are Chiseled Containers?

Chiseled containers represent a paradigm shift in container image design philosophy. Traditional container images often include a multitude of unnecessary components, leading to larger sizes and increased security vulnerabilities. The core concept behind chiseled containers is to meticulously trim away non-essential elements, creating a lean and secure deployment vehicle for cloud applications.

Key Features of Chiseled Containers

1. Size and Security Optimization

One of the primary challenges in managing container images is handling Common Vulnerabilities and Exposures (CVEs). Chiseled containers address this issue by significantly reducing the number of components, thereby minimizing the attack surface. A comparative analysis using anchore/syft commands demonstrates a stark difference in the number of components between chiseled and non-chiseled images.

$ docker run --rm anchore/syft mcr.microsoft.com/dotnet/runtime:8.0 | grep deb | wc -l
92
$ docker run --rm anchore/syft mcr.microsoft.com/dotnet/runtime:8.0-jammy-chiseled | grep deb | wc -l
7

The reduction in component count enhances the security posture and simplifies CVE management.

2. Smaller Image Footprint

Chiseled containers boast a significantly smaller footprint compared to their non-chiseled counterparts. For instance, the uncompressed size of the .NET aspnet image is approximately 110MB for the chiseled variant, rivaling the size of Alpine, a well-known lightweight base image.

$ docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}" | grep mcr.microsoft.com/dotnet/aspnet
mcr.microsoft.com/dotnet/aspnet 8.0-jammy-chiseled 110MB
mcr.microsoft.com/dotnet/aspnet 8.0-alpine 112MB

This reduction in size contributes to faster image pull times and optimized resource utilization.

3. Distroless Form Factor

Chiseled containers embody the distroless form factor, emphasizing only the essential components required for application execution. Unlike traditional Linux distributions, they exclude unnecessary tools and package managers, leading to a more secure runtime environment.

How to Use .NET Chiseled Containers

1. Tag and Versioning

Chiseled container images are available in the container repositories with the following tag: 8.0-jammy-chiseled. The version number may vary for .NET 6 and 7 variants.

2. Image Selection

Selecting the appropriate image type depends on the deployment requirements:

Framework-Dependent Deployment:
- Maximum layer sharing for faster build times.
- Recommended for hosting multiple .NET apps on the same machine.
Self-Contained Apps:
- Significantly smaller image size but limited layer sharing.
- Suitable for scenarios where size optimization is a priority.
Native AOT (Ahead-of-Time) Apps:
- Further reduces image size, particularly for console apps and services.

3. Security Considerations

Chiseled containers enhance security by excluding shells, package managers, and minimizing the attack surface. Furthermore, these containers are shipped as non-root, limiting the potential impact of malicious activities.

Adoption and Future Outlook

Chiseled containers represent a significant advancement in the .NET container image portfolio. While .NET 8 users are the most immediate beneficiaries, users of Ubuntu and Debian stand to gain substantial size savings by adopting chiseled containers.

Microsoft and Canonical recommend careful consideration of chiseled containers, emphasizing their benefits in terms of reduced image size, enhanced security, and simplified CVE management. The collaboration between the two companies signals a commitment to ongoing support and potential advancements in containerization.

In conclusion, the era of chiseled containers has arrived, promising a revolution in how developers approach containerized application deployment. As the adoption of chiseled containers grows, it is anticipated that other developer ecosystems, such as Java, Python, and Node.js, will explore and offer their own versions of chiseled images. The future of containerization looks more efficient, secure, and streamlined with the introduction of .NET chiseled containers.

Asynchronous Programming in C#: A Practical Guide

Tue, 21 Nov 2023 08:45:42 +0000

As applications grow in complexity, the need for responsive and efficient code becomes paramount. Asynchronous programming in C# offers a powerful solution to handling time-consuming operations without blocking the main thread. This practical guide aims to demystify asynchronous programming in C#, providing a comprehensive overview and practical examples to help you harness the benefits of asynchronous operations.

1. Understanding Asynchronous Programming

Explanation of synchronous vs. asynchronous operations.
The importance of asynchronous programming for responsiveness and scalability.
Introduction to the async and await keywords.

2. Basics of Asynchronous Methods

a. Async Methods

Creating asynchronous methods using the async keyword.
Returning Task or Task<T> from asynchronous methods.

C# Example:

async Task<string> DownloadDataAsync()
{
// Asynchronous operation
 return await SomeApi.DownloadDataAsync();
}

b. Awaitable Types

Understanding types that can be awaited (e.g., Task, Task<T>, ValueTask<T>).
Handling asynchronous operations without blocking the thread.

C# Example:

async Task PerformAsyncOperation()
{
// Asynchronously wait for the result
 var result = await SomeClass.PerformOperationAsync();
}

3. Asynchronous Patterns

a. Async and Await Best Practices

Best practices for using async and await keywords.
Avoiding blocking calls in asynchronous methods.

C# Example:

async Task<int> CalculateSumAsync()
{
var result1 = await Task.Run(() => ComputePart1());
var result2 = await Task.Run(() => ComputePart2());
return result1 + result2;
}

b. Task.WhenAll and Task.WhenAny

Utilizing Task.WhenAll for parallel asynchronous operations.
Using Task.WhenAny for scenarios where the first completed task is needed.

C# Example:

async Task<string[]> DownloadAllDataAsync()
{
var downloadTasks = urls.Select(url => DownloadDataAsync(url));
return await Task.WhenAll(downloadTasks);
}

4. Exception Handling in Asynchronous Code

Handling exceptions in asynchronous code.
Using try, catch, and finally with asynchronous methods.

C# Example:

async Task<int> DivideAsync(int a, int b)
{
try
{
return await Task.Run(() => a / b);
}
catch (DivideByZeroException ex)
{
Console.WriteLine($"Division by zero: {ex.Message}");
throw;
}
}

5. Asynchronous File I/O and Network Operations

a. Reading and Writing Files Asynchronously

Performing file I/O operations asynchronously.
Using StreamReader, StreamWriter, and FileStream asynchronously.

C# Example:

async Task ReadWriteFileAsync(string inputFile, string outputFile)
{
using (var reader = new StreamReader(inputFile))
using (var writer = new StreamWriter(outputFile))
{
var content = await reader.ReadToEndAsync();
await writer.WriteAsync(content);
}
}

b. Making Asynchronous Web Requests

Utilizing asynchronous HTTP requests using HttpClient.
Handling responses asynchronously.

C# Example:

async Task<string> DownloadDataAsync(string url)
{
using (var client = new HttpClient())
{
return await client.GetStringAsync(url);
}
}

6. Synchronization Context and Task.Run

Understanding the Synchronization Context and its impact on asynchronous code.
Using Task.Run to offload CPU-bound work to a separate thread.

C# Example:

async Task RunTaskOnThreadPool()
{
await Task.Run(() =>
{
// Code to run on a separate thread
 });
}

Conclusion

Asynchronous programming in C# is a powerful tool for improving the performance and responsiveness of your applications. This guide has covered the fundamentals of asynchronous programming, from basic syntax to best practices and real-world examples. By incorporating asynchronous techniques into your codebase, you can create more efficient and scalable applications that meet the demands of modern software development.

C# Design Patterns: A Practical Guide

Mon, 20 Nov 2023 20:25:34 +0000

Design patterns offer reusable solutions to common problems in software design, providing a framework for creating flexible and maintainable code. In C#, understanding and implementing design patterns can significantly enhance the structure and efficiency of your applications. This practical guide will explore key design patterns in C#, providing real-world examples to illustrate their application.

1. Understanding Design Patterns

Design patterns are proven solutions to recurring design problems.
Three main categories: Creational, Structural, and Behavioral.

2. Creational Design Patterns

a. Singleton Pattern

Ensures a class has only one instance and provides a global point to that instance.

C# Implementation:

public class Singleton
{
private static Singleton _instance;
private Singleton() { }
public static Singleton Instance
{
get
{
if (_instance == null)
{
_instance = new Singleton();
}
return _instance;
}
}
}

b. Factory Method Pattern

Defines an interface for creating an object but lets subclasses alter the type of objects that will be created.

C# Implementation:

public interface IProduct
{
void Produce();
}
public class ConcreteProduct : IProduct
{
public void Produce() => Console.WriteLine("Producing Concrete Product");
}
public abstract class Creator
{
public abstract IProduct FactoryMethod();
}
public class ConcreteCreator : Creator
{
public override IProduct FactoryMethod() => new ConcreteProduct();
}

c. Abstract Factory Pattern

Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

C# Implementation:

public interface IAbstractFactory
{
IProductA CreateProductA();
IProductB CreateProductB();
}
public interface IProductA { }
public interface IProductB { }
public class ConcreteFactory : IAbstractFactory
{
public IProductA CreateProductA() => new ConcreteProductA();
public IProductB CreateProductB() => new ConcreteProductB();
}
public class ConcreteProductA : IProductA { }
public class ConcreteProductB : IProductB { }

3. Structural Design Patterns

a. Adapter Pattern

Allows incompatible interfaces to work together.

C# Implementation:

public interface ITarget
{
void Request();
}
public class Adaptee
{
public void SpecificRequest() => Console.WriteLine("Specific Request");
}
public class Adapter : ITarget
{
private readonly Adaptee _adaptee;
public Adapter(Adaptee adaptee) => _adaptee = adaptee;
public void Request() => _adaptee.SpecificRequest();
}

b. Decorator Pattern

Attaches additional responsibilities to an object dynamically.

C# Implementation:

public interface IComponent
{
void Operation();
}
public class ConcreteComponent : IComponent
{
public void Operation() => Console.WriteLine("Concrete Component");
}
public class Decorator : IComponent
{
private readonly IComponent _component;
public Decorator(IComponent component) => _component = component;
public void Operation()
{
_component.Operation();
Console.WriteLine(" + Decorator");
}
}

c. Composite Pattern

Composes objects into tree structures to represent part-whole hierarchies.

C# Implementation:

public abstract class Component
{
public abstract void Operation();
}
public class Leaf : Component
{
public override void Operation() => Console.WriteLine("Leaf Operation");
}
public class Composite : Component
{
private readonly List<Component> _children = new List<Component>();
public void Add(Component component) => _children.Add(component);
public override void Operation()
{
Console.WriteLine("Composite Operation");
foreach (var child in _children)
{
child.Operation();
}
}
}

4. Behavioral Design Patterns

a. Observer Pattern

Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.

C# Implementation:

public interface IObserver
{
void Update(string message);
}
public class ConcreteObserver : IObserver
{
public void Update(string message) => Console.WriteLine($"Received update: {message}");
}
public class Subject
{
private readonly List<IObserver> _observers = new List<IObserver>();
public void Attach(IObserver observer) => _observers.Add(observer);
public void NotifyObservers(string message)
{
foreach (var observer in _observers)
{
observer.Update(message);
}
}
}

b. Strategy Pattern

Defines a family of algorithms, encapsulates each one, and makes them interchangeable.

C# Implementation:

public interface IStrategy
{
void Execute();
}
public class ConcreteStrategyA : IStrategy
{
public void Execute() => Console.WriteLine("Executing Strategy A");
}
public class ConcreteStrategyB : IStrategy
{
public void Execute() => Console.WriteLine("Executing Strategy B");
}
public class Context
{
private IStrategy _strategy;
public Context(IStrategy strategy) => _strategy = strategy;
public void SetStrategy(IStrategy strategy) => _strategy = strategy;
public void ExecuteStrategy() => _strategy.Execute();
}

c. Command Pattern

Encapsulates a request as an object, thereby allowing for parameterization of clients with different requests, queuing of requests, and logging of the requests.

C# Implementation:

public interface ICommand
{
void Execute();
}
public class ConcreteCommand : ICommand
{
private readonly Receiver _receiver;
public ConcreteCommand(Receiver receiver) => _receiver = receiver;
public void Execute() => _receiver.Action();
}
public class Receiver
{
public void Action() => Console.WriteLine("Receiver Action");
}
public class Invoker
{
private ICommand _command;
public void SetCommand(ICommand command) => _command = command;
public void ExecuteCommand() => _command.Execute();
}

Conclusion

This practical guide has introduced several fundamental design patterns in C#, providing both conceptual understanding and practical implementations. Incorporating these patterns into your projects can significantly improve code organization, maintainability, and flexibility. As you delve deeper into C# development, consider exploring more design patterns tailored to your specific application needs.

Exploring What's New in C# 12

Tue, 14 Nov 2023 21:15:20 +0000

C# 12 has arrived, bringing a plethora of features aimed at enhancing developer productivity, simplifying code, and boosting application performance. Let’s delve into the key improvements introduced in this latest version.

Getting Started with C# 12

To leverage the new features of C# 12, developers are encouraged to download .NET 8, the latest Visual Studio, or Visual Studio Code’s C# Dev Kit. Existing projects can be upgraded by indicating the desired language version, accomplished by changing the TargetFramework to .NET 8.0 in the project file.

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<!-- ... -->
</PropertyGroup>
</Project>

Simplifying Code for Better Productivity

C# 12 focuses on streamlining code, making it more expressive and efficient without sacrificing performance. The improvements can be explored in detail in the “What’s new in C# 12” article on MS Learn, which also provides links to updated documentation.

Collection Expressions

One notable enhancement is the introduction of collection expressions, offering a unified syntax for creating collections. Before C# 12, different scenarios required varied syntax for initializing collections. Now, developers can use a single syntax for arrays, lists, spans, and more:

int[] x1 = [1, 2, 3, 4];
int[] x2 = [];
WriteByteArray([1, 2, 3]);
List<int> x4 = [1, 2, 3, 4];
Span<DateTime> dates = [GetDate(0), GetDate(1)];
WriteByteSpan([1, 2, 3]);

The compiler generates optimized code, often improving performance and avoiding unnecessary data copying. Additionally, a new spread operator allows the inclusion of elements from multiple collections within a single expression.

Primary Constructors on Any Class or Struct

C# 12 extends primary constructors to work on all classes and structs, not just records. This feature enables the definition of constructor parameters directly in the class declaration, simplifying code and reducing boilerplate:

public class BankAccount(string accountID, string owner)
{
public string AccountID { get; } = accountID;
public string Owner { get; } = owner;
public override string ToString() => $"Account ID: {AccountID}, Owner: {Owner}";
}

Primary constructors serve various purposes, such as providing arguments to a base constructor, initializing fields or properties, and reducing boilerplate in dependency injection.

Alias Any Type

C# 12 introduces the ability to alias any type using using alias directives. This allows developers to remove complex type signatures from their code, improving readability:

using intArray = int[]; // Array types.
using Point = (int x, int y); // Tuple type
using unsafe ArrayPtr = int*; // Pointer type (requires "unsafe")

These type aliases can be used at the top of a file and in global using statements.

Default Lambda Parameters

Lambda expressions in C# 12 support default parameters, allowing developers to skip passing values and add parameters to existing lambda expressions without breaking calling code:

var IncrementBy = (int source, int increment = 1) => source + increment;
Console.WriteLine(IncrementBy(5)); // 6
Console.WriteLine(IncrementBy(5, 2)); // 7

This feature simplifies accessing lambda expressions and aligns with the simplicity offered by default parameters in regular methods.

Making Code Faster with Raw Memory Improvements

C# 12 continues to enhance raw memory capabilities, contributing to improved application performance. Two key additions are ref readonly parameters and inline arrays.

Ref Readonly Parameters

The introduction of ref readonly parameters provides a final combination of passing parameters by reference or by value. These parameters must be variables, enhancing memory optimization:

void ProcessData(ref readonly int data)
{
// Access data without modification
}

Inline Arrays

Inline arrays offer a safe way to work with memory buffers, providing a struct-based, fixed-length array type. Developers can manipulate blocks of memory without enabling unsafe code, thereby improving application performance:

struct InlineArray<T>
{
private T[] data;
// Implementation details...
}

Experimental Features: Pushing the Boundaries

C# 12 introduces experimental features, including the experimental attribute and interceptors, aimed at gathering feedback and exploring new possibilities.

Experimental Attribute

The experimental attribute is applied to types, members, and assemblies, signaling that the feature is under exploration and not yet committed to the implementation. This allows developers to suppress errors for individual experimental features and explore them using explicit compiler options or pragmas.

Interceptors

Interceptors, available in preview mode with C# 12, enable the redirection of method calls. This experimental feature allows an optimized version of a method, generated for specific parameters, to replace a less efficient generalized method.

Developers interested in these experimental features are encouraged to mark their code accordingly, using the ExperimentalAttribute to indicate the experimental nature of their libraries.

Conclusion

C# 12 introduces a wealth of features aimed at improving developer productivity, simplifying code, and enhancing application performance. From unified collection expressions to primary constructors on any class or struct, type aliases, default lambda parameters, and raw memory improvements, developers have an array of tools to streamline their code and build faster, more efficient applications. Additionally, the inclusion of experimental features demonstrates a commitment to exploring new possibilities and gathering valuable feedback from the developer community. As developers embrace C# 12, they can look forward to a more expressive and performant coding experience.

Optimizing SQL Queries in Entity Framework Core

Sun, 12 Nov 2023 07:29:50 +0000

Entity Framework Core (EF Core) is a powerful and widely used Object-Relational Mapping (ORM) framework for .NET applications. While EF Core simplifies database interactions, it’s essential to optimize SQL queries generated by EF Core to ensure efficient database performance. In this article, we’ll explore various strategies and techniques for optimizing SQL queries in Entity Framework Core, backed by examples and explanations.

Lazy Loading vs. Eager Loading

EF Core supports lazy loading and eager loading for related entities. Lazy loading defers the loading of related entities until they are explicitly accessed, potentially leading to the N+1 query problem. Eager loading, on the other hand, loads related entities along with the main entity in a single query.

Example:

// Lazy loading
var order = dbContext.Orders.First();
var customer = order.Customer; // Generates a separate query to load the customer

// Eager loading
var orderWithCustomer = dbContext.Orders.Include(o => o.Customer).First();

Explanation: Use eager loading with the Include method to fetch related entities in a single query, reducing the number of round trips to the database.

Projection for Specific Columns

Selecting only the necessary columns instead of retrieving all columns can significantly improve query performance.

Example:

// Without projection
var products = dbContext.Products.Where(p => p.Category == "Electronics").ToList();
// With projection
var products = dbContext.Products
.Where(p => p.Category == "Electronics")
.Select(p => new { p.Id, p.Name, p.Price })
.ToList();

Explanation: By projecting only the required columns, you reduce the amount of data retrieved from the database, leading to better performance.

Batching Queries with `AsNoTracking`

The AsNoTracking method can be used to indicate that the entities retrieved from the database should not be tracked for changes. This can improve query performance, especially when dealing with read-only operations.

Example:

var orders = dbContext.Orders.AsNoTracking().ToList();

Explanation: When entities are not tracked, EF Core doesn’t spend resources keeping track of changes, resulting in faster queries for read-only scenarios.

Indexing for Better Performance

Ensure that the database tables involved in EF Core queries are appropriately indexed. Indexing can significantly speed up data retrieval operations.

Example:

// Index on the 'Category' column
[Index(nameof(Category))]
public class Product
{
// ... other properties
}

Explanation: Creating indexes on columns frequently used in queries improves database search performance.

Optimizing `WHERE` Clauses

EF Core translates LINQ queries into SQL, but the generated SQL might not always be optimal. Be mindful of how complex LINQ expressions are translated into SQL queries, and consider using raw SQL for more control.

Example:

// Inefficient WHERE clause
var expensiveProducts = dbContext.Products.Where(p => p.Price * 1.2 > 100).ToList();
// Optimized WHERE clause
var expensiveProducts = dbContext.Products.FromSqlRaw("SELECT * FROM Products WHERE Price > {0}", 100 / 1.2).ToList();

Explanation: In some cases, using raw SQL for complex queries can provide better performance than relying solely on LINQ.

Conclusion

Optimizing SQL queries in Entity Framework Core is crucial for ensuring the efficiency of database operations. By employing the strategies discussed in this article, you can enhance the performance of your EF Core queries and, in turn, deliver a more responsive and scalable application.

The Dual Nature of Artificial Intelligence: Strengths and Limitations

Sat, 11 Nov 2023 07:21:53 +0000

In the current landscape of technology, Artificial Intelligence stands out as the transformative force with the potential to reshape industries and redefine how we interact with the world. While the capabilities of AI are undoubtedly impressive, a comprehensive understanding of its strengths and limitations is essential for harnessing its potential responsibly.

Strengths of AI

Data Processing and Pattern Recognition: Artificial Intelligence excels in managing and interpreting vast datasets, far beyond the capacity of human capabilities. Machine learning algorithms enable AI systems to analyze complex patterns and trends swiftly. In the realm of healthcare, for instance, AI plays a pivotal role in diagnosing diseases by rapidly identifying subtle patterns in medical images, thereby enhancing accuracy and efficiency in patient care.
Repetitive and Rule-Based Tasks: One of the hallmarks of AI is its ability to automate repetitive, rule-based tasks. In industries such as manufacturing and logistics, AI-powered robotic systems are deployed to perform monotonous duties with precision and consistency. This not only increases operational efficiency but also minimizes the risk of human errors, contributing to safer and more reliable processes.
Natural Language Processing (NLP): AI’s proficiency in Natural Language Processing (NLP) empowers it to understand, interpret, and generate human-like language. Virtual assistants, language translation services, and chatbots leverage NLP to facilitate seamless communication across various domains. These technologies play a vital role in enhancing user experiences, breaking down language barriers, and providing efficient solutions in customer service and information retrieval.

Limitations of AI

Lack of Common Sense and Context Understanding: Despite its prowess in data analysis, AI often struggles with understanding common sense and interpreting context as effortlessly as humans. In scenarios requiring nuanced interpretation or situations where background knowledge is crucial, AI systems may falter. This limitation poses challenges in areas such as customer service, content creation, and interpersonal communication, where context is paramount for accurate decision-making.
Ethical Decision-Making: The ethical dimension of decision-making remains a significant challenge for AI. While AI systems can process data and make decisions based on predefined algorithms, they lack the inherent ethical compass and moral reasoning that humans possess. Issues related to bias in AI decision-making have raised concerns, particularly in critical areas such as criminal justice and hiring processes, emphasizing the need for human oversight to ensure fairness and accountability.
Creativity and Emotional Intelligence: The creative and emotional realms remain distinctly human domains where AI faces limitations. While AI can generate content, mimic artistic styles, and compose music, it often lacks the depth of originality and emotional nuance that human creativity brings to these endeavors. Fields such as art, literature, and music thrive on the unique perspectives, emotions, and imaginative capacities of humans, underscoring the irreplaceable nature of the human touch in creative pursuits.

Conclusion

Artificial Intelligence represents a double-edged sword, offering unparalleled strengths in data processing, automation, and language understanding, yet grappling with challenges related to common sense, ethical decision-making, and the intricacies of creativity. As we navigate the evolving landscape of AI, a nuanced approach is crucial, emphasizing responsible deployment and ongoing collaboration between humans and machines. By leveraging AI’s strengths while addressing its limitations, we can pave the way for a harmonious integration of technology into our complex and dynamic world, ensuring that it serves humanity in the most beneficial and ethical manner possible.

From Chaos to Clarity: The Tale of PHP and .NET Naming

Fri, 10 Nov 2023 07:24:39 +0000

Programming languages play a crucial role in shaping the way developers write code. Among the myriad of languages, PHP and .NET stand out for their distinct approaches to naming conventions. In this article, we’ll explore the stark differences in naming conventions between PHP and .NET and the reasons behind them.

The World of PHP: A Landscape of Inconsistencies

PHP, a popular scripting language, has a reputation for its loose and sometimes inconsistent naming conventions. This can be attributed to its evolution and the diverse set of contributors over the years. Let’s delve into some of the key characteristics that define PHP naming:

1. Case Sensitivity

One of the notable features of PHP is its case-insensitive nature. This means that variables, functions, and class names are not case-sensitive. For example, $myVariable, $myvariable, and $MyVariable all refer to the same variable.

2. Underscore vs. Camel Case

PHP exhibits a mix of naming styles. While underscores are commonly used to separate words in variable names ($my_variable), camel case is also prevalent in function and method names (myFunction()).

3. Global Functions and Namespace Collision

PHP includes a vast set of global functions, which can sometimes lead to naming conflicts. This underscores the importance of properly namespacing functions and classes in larger projects.

The .NET Paradigm: A World of Rigorous Naming Conventions

In stark contrast to PHP, the .NET framework adheres to a set of strict and consistent naming conventions. These conventions are designed to promote readability, maintainability, and interoperability across different parts of the .NET ecosystem:

1. Pascal Case and Camel Case

In .NET, Pascal case is the standard for naming classes, methods, and properties (MyClass, MyMethod, MyProperty). Camel case is used for naming parameters and local variables (myVariable, myParameter).

2. Namespaces for Clarity

.NET encourages the use of namespaces to organise and group related classes and prevent naming collisions. This helps maintain a clear and structured codebase, especially in larger projects.

3. Consistency Across the Framework

The .NET Framework, including languages like C# and VB.NET, maintains a high degree of naming consistency. This consistency extends to method names, event handlers, and design patterns, making it easier for developers to navigate and understand code.

Reasons Behind the Divide

The differing naming conventions in PHP and .NET can be attributed to their respective histories, design philosophies, and communities.

PHP’s evolution has been marked by a more relaxed and adaptable approach, allowing for quick development and prototyping. This flexibility can lead to a wide range of naming styles, reflecting the diverse backgrounds and preferences of PHP developers.

On the other hand, the .NET framework was designed with a strong emphasis on enterprise-level development, where consistency and maintainability are paramount. The framework’s strict naming conventions facilitate collaboration and codebase longevity.

Striking a Balance

While PHP and .NET have distinct naming conventions, it’s important to remember that both have their strengths and can be leveraged effectively in different contexts. PHP’s flexibility can be advantageous in rapid development scenarios, while .NET’s rigor provides a solid foundation for large-scale, long-term projects.

In the end, the choice of naming conventions should align with the specific needs and goals of a project. Understanding the nuances of each language’s conventions empowers developers to make informed decisions that lead to cleaner, more maintainable code.

Navigating the world of naming conventions is a crucial aspect of software development. Whether you’re in the dynamic realm of PHP or the structured environment of .NET, mastering the art of naming will undoubtedly contribute to code that is not only functional but also a pleasure to work with. Happy coding!

Why is AI So Bad at Financial Trading When Computers Are Just Better at Maths

Thu, 09 Nov 2023 07:16:20 +0000

One thing that everybody would have assumed that Machine Learning/AI would have been good at, given it is very good at forcasting, anomaly detection and maths in general, is financial trading. The problem is that several studies have shown that AI running on some very powerful machines is no better than any given human trader.

It made me wonder, why is AI so bad at trading compared to what it should be?

There are several reasons why AI may not always perform as well as humans in financial trading:

Lack of Contextual Understanding: AI models, including sophisticated ones like GPT-3 or GPT-4, lack a true understanding of context. They generate responses based on patterns they’ve learned from training data, but they don’t actually comprehend the content in the way humans do. This can be a significant disadvantage in understanding complex financial markets.
Unpredictable Market Conditions: Financial markets can be highly unpredictable, especially in the short term. Sudden events, news, or geopolitical shifts can significantly impact prices, and it’s challenging for AI models to adapt quickly to such changes.
Limited Training Data: AI models rely on historical data to make predictions. If a model is trained on a limited dataset, it may not have seen a wide enough range of market conditions to make accurate predictions in all situations.
Overfitting and Generalization Issues: AI models can sometimes become overly specialised in the data they were trained on. This is known as overfitting. They may not generalise well to new, unseen data, which is crucial in the constantly changing landscape of financial markets.
Lack of Common Sense and Intuition: Humans have a deep understanding of the world and financial systems that is difficult to replicate in AI. This includes common sense, intuition, and an ability to interpret non-quantitative information (like news events, geopolitical factors, etc.) that may influence market movements.
Regulatory Constraints: Financial markets are highly regulated, and AI models may not always comply with all regulatory requirements. Compliance with legal and ethical standards is crucial in trading.
Risk Management and Decision-making under Uncertainty: Humans can exercise judgment and make decisions under uncertainty, considering factors that are not easily quantifiable. They can also incorporate risk management strategies based on their experience and intuition, which can be difficult for AI models to replicate.
Lack of Emotional Intelligence: While emotions can sometimes lead to irrational decisions, they can also provide valuable insights and gut instincts. AI models don’t have emotions or instincts in the same way humans do.
Market Manipulation and Game Theory: Humans are often engaged in strategic behavior and game theory when participating in financial markets. Understanding and anticipating these behaviors can be challenging for AI models.

It’s worth noting that while AI can have advantages in certain aspects of trading (e.g., processing large amounts of data quickly), it’s not a one-size-fits-all solution. Some trading strategies may benefit more from human intuition and judgment, while others may benefit from algorithmic approaches. In practice, a combination of human expertise and AI tools is often the most effective approach in financial trading.

Solving Common Database Performance Bottlenecks

Wed, 08 Nov 2023 07:11:49 +0000

A well-optimised database is the cornerstone of any high-performance application. However, as data grows and user demands increase, databases can face performance bottlenecks that hinder application responsiveness. In this article, we’ll explore some common database performance issues and strategies to overcome them.

1. Inefficient Queries

Inefficient queries are a prevalent cause of database performance issues. These can lead to slow response times and put unnecessary strain on the database server. For example, a query that retrieves all columns when only a few are needed can be highly inefficient.

Solution: Query Optimization

Consider the following example. Instead of using:

SELECT * FROM users WHERE status = 'active';

Use:

SELECT id, username, email FROM users WHERE status = 'active';

This way, only the necessary columns are retrieved, reducing the workload on the database.

2. Insufficient Indexing

Insufficient or improper indexing can lead to full table scans, where the database has to search through every record to find the desired information. This can drastically slow down query performance.

Solution: Proper Indexing

For example, suppose you have a table named products with columns product_id and category. Creating an index on category can significantly speed up queries like:

SELECT * FROM products WHERE category = 'Electronics';

3. Hardware Limitations

Hardware limitations can be a significant bottleneck for database performance. This includes limitations on CPU, memory, or disk I/O. As data and user load grow, the existing hardware may become insufficient.

Solution: Scaling and Optimization

Vertical scaling involves upgrading individual components, like increasing CPU cores or adding more RAM. For instance, upgrading from a dual-core to a quad-core CPU can lead to substantial performance improvements.

Horizontal scaling involves distributing the load across multiple servers. Techniques like database sharding, where data is partitioned across multiple servers, can significantly improve performance for large-scale applications.

4. Inadequate Database Design

Inadequate database design can lead to performance bottlenecks. This may include issues like redundant data, inefficient normalization, or poor use of data types.

Solution: Database Design Best Practices

For instance, consider an e-commerce application. Properly normalizing tables for orders and products, while denormalizing for high-frequency queries like product listings, can strike a balance between performance and data integrity.

5. Locking and Concurrency Issues

Concurrency issues arise when multiple users or processes try to access and modify the same data simultaneously. This contention can lead to reduced performance and even deadlocks.

Solution: Optimistic Concurrency Control

Optimistic Concurrency Control (OCC) is a technique that allows multiple transactions to proceed concurrently, assuming they won’t interfere with each other. It involves using timestamps or version numbers to track changes.

6. Inadequate Database Maintenance

Regular maintenance tasks like vacuuming, reindexing, and cleaning up stale data are crucial for optimal database performance.

Solution: Scheduled Maintenance

For example, setting up a nightly job to perform a VACUUM operation on a PostgreSQL database can reclaim space and improve performance. Additionally, regular index maintenance and statistics updates are essential for query optimization.

7. Suboptimal Configuration

Database server configurations may not be optimised for the workload, leading to performance bottlenecks.

Solution: Configuration Tuning

Regularly reviewing and adjusting configuration settings based on the specific workload and hardware specifications is crucial. For example, adjusting the maximum connection pool size or buffer cache size based on application demands can significantly improve performance.

By identifying and addressing these common database performance bottlenecks, you can ensure your application runs smoothly, even under heavy loads. Remember that ongoing monitoring, testing, and optimization are key to maintaining high-performance databases in the long run.

Happy optimizing!

Mastering Git: Tips and Tricks for Version Control

Tue, 07 Nov 2023 07:01:41 +0000

Version control is a crucial aspect of modern software development. It allows multiple developers to collaborate on a project while keeping track of changes and managing code efficiently. Among the various version control systems available, Git has emerged as one of the most popular and powerful tools.

In this article, we’ll delve into some advanced Git tips and tricks, accompanied by practical examples, to help you become a more proficient version control practitioner.

1. Branching Strategies

Git’s branching capabilities are powerful. Adopting a solid branching strategy can significantly improve your workflow. Consider using strategies like Gitflow, GitHub Flow, or Trunk-Based Development, depending on the nature and size of your projects.

Example: Using Gitflow

# Initialise a new Gitflow repository
git flow init
# Start a new feature branch
git flow feature start new-feature
# Finish a feature branch
git flow feature finish new-feature

2. Rebasing vs. Merging

Understanding when to use rebasing versus merging is key to maintaining a clean and readable Git history. While merging combines the changes from one branch into another, rebasing integrates changes by moving or combining a sequence of commits to a new base commit.

Example: Rebasing

# Switch to the target branch
git checkout target-branch
# Perform a rebase
git rebase source-branch

3. Interactive Rebase

The interactive rebase allows you to edit, combine, or reorder commits before merging them into a branch. This can help maintain a cleaner commit history and resolve conflicts more effectively.

Example: Interactive Rebase

# Start an interactive rebase
git rebase -i HEAD~3
# In the interactive editor, you can squash, reword, or reorder commits

4. Stash Uncommitted Changes

The git stash command is a lifesaver when you need to switch branches but have uncommitted changes. It temporarily saves your work and allows you to switch to a different branch without committing incomplete code.

Example: Stashing Changes

# Save current changes to the stash
git stash
# Switch branches
git checkout other-branch
# Apply stashed changes
git stash apply

5. Cherry-Picking Commits

Cherry-picking is a technique used to apply specific commits from one branch to another. This can be helpful when you want to selectively include changes without merging an entire branch.

Example: Cherry-Picking

# Switch to the target branch
git checkout target-branch
# Cherry-pick a specific commit
git cherry-pick <commit-hash>

6. Aliases

Git aliases allow you to create shortcuts for frequently used commands. For example, you can create an alias to replace git status with a shorter command like git st.

Example: Creating an Alias

git config --global alias.st status

7. Custom Hooks

Git hooks are scripts that Git executes before or after events like commit, push, and receive. By using custom hooks, you can automate tasks like code formatting, linting, or running tests.

Example: Pre-commit Hook

# Create a pre-commit hook script
echo "npm run lint" > .git/hooks/pre-commit
# Make the script executable
chmod +x .git/hooks/pre-commit

8. Reflog

The reflog is a powerful tool for recovering lost commits or branches. It records the history of every HEAD change in the repository, allowing you to undo actions or find lost work.

Example: Viewing the Reflog

# View the reflog
git reflog

9. Git Bisect

Git bisect is a powerful debugging tool that helps you find the specific commit where a bug was introduced. It uses a binary search algorithm to efficiently narrow down the problematic commit.

Example: Using Git Bisect

# Start the bisect process
git bisect start
# Mark the current commit as bad
git bisect bad
# Mark a known good commit
git bisect good <commit-hash>

10. Using Git Worktrees

Git worktrees allow you to have multiple working directories from a single repository. This can be incredibly useful when you need to work on different features concurrently.

Example: Creating a Worktree

# Create a new worktree
git worktree add ../my-feature-branch feature-branch

Mastering Git is a journey that requires practice and a willingness to explore its powerful features. By incorporating these tips and tricks into your workflow, you’ll not only become a more proficient Git user but also enhance your overall efficiency in version control.

Remember, the key to success in version control is consistent practice and a willingness to learn from your experiences. Happy coding!

Image Recognition with C# and AI: A Practical Guide

Mon, 06 Nov 2023 07:01:41 +0000

Image recognition has become a fundamental component of many applications, from medical imaging, autonomous vehicles and even the ANPR cameras that make parking your car so much easier. In this article, we’ll explore how to implement image recognition using C# and harness the power of artificial intelligence (AI) to identify objects, scenes, and patterns within images.

Understanding Image Recognition

Image recognition, also known as computer vision, is the process of using software to analyze and interpret visual data from the world. This technology enables computers to “see” and understand the content of images, making it invaluable in a wide range of applications.

Choosing the Right AI Frameworks

When it comes to image recognition with C#, there are several powerful AI frameworks to consider. One popular choice is the TensorFlow.NET library, which provides a seamless interface to the TensorFlow deep learning framework within C#. Another option is Microsoft’s Cognitive Services, which offers pre-trained models for image recognition tasks.

Getting Started with TensorFlow.NET

TensorFlow.NET is an open-source library that allows you to utilise the TensorFlow framework in your C# applications. Let’s walk through a simple example of image recognition using TensorFlow.NET:

using TensorFlow;
using System;
using System.Drawing;
using System.IO;
class Program
{
static void Main(string[] args)
{
var modelPath = "<PATH_TO_YOUR_MODEL>";
var imageFilePath = "<PATH_TO_YOUR_IMAGE>";
using (var session = new TFSession())
{
var graph = new TFGraph();
var model = File.ReadAllBytes(modelPath);
graph.Import(model);
var tensor = ImageUtil.CreateTensorFromImageFile(imageFilePath);
var runner = session.GetRunner();
runner.AddInput(graph["input"][0], tensor).Fetch(graph["output"][0]);
var output = runner.Run();
var result = output[0].GetValue() as float[,];
// Process the result for interpretation
 // ...
 }
}
}

In this example, we load a pre-trained model into TensorFlow.NET and use it to perform image recognition on an input image file.

Utilizing Microsoft Cognitive Services

Microsoft Cognitive Services provides a range of pre-trained models for image recognition tasks. Let’s look at how to use the Computer Vision API for image analysis:

using Microsoft.Azure.CognitiveServices.Vision.ComputerVision;
using Microsoft.Azure.CognitiveServices.Vision.ComputerVision.Models;
using System;
class Program
{
static async Task Main(string[] args)
{
var endpoint = "<YOUR_COGNITIVE_SERVICES_ENDPOINT>";
var apiKey = "<YOUR_API_KEY>";
var client = new ComputerVisionClient(new ApiKeyServiceClientCredentials(apiKey))
{
Endpoint = endpoint
};
var imageFilePath = "<PATH_TO_YOUR_IMAGE>";
var features = new List<VisualFeatureTypes>
{
VisualFeatureTypes.Description,
VisualFeatureTypes.Categories,
VisualFeatureTypes.Tags
};
using (var stream = File.OpenRead(imageFilePath))
{
var analysis = await client.AnalyzeImageInStreamAsync(stream, features);
// Process the analysis results
 // ...
 }
}
}

In this example, we use the Computer Vision API to analyze an image and obtain descriptive information about its content.

Real-world Applications

Image recognition has found applications in various fields, including healthcare, autonomous vehicles, retail, and more. Whether it’s identifying diseases in medical images or enabling self-driving cars to navigate safely, the possibilities are vast.

Conclusion

By combining the power of C# with AI, you can implement image recognition in your applications, opening up a world of possibilities for visual data analysis. Whether you choose TensorFlow.NET or leverage Microsoft’s Cognitive Services, the ability to interpret images can revolutionise the capabilities of your software. So, dive in, start experimenting, and unlock the potential of image recognition in your projects!

Unleashing the Power of C#: Integrating AI for Intelligent Applications

Sun, 05 Nov 2023 18:00:00 +0000

Harnessing the potential of artificial intelligence (AI) can elevate your C# applications to a new level of intelligence. In this article, we’ll explore how to seamlessly integrate AI into your C# projects, with practical examples to illustrate each step.

C# is a versatile and powerful programming language that excels in creating robust applications across various domains. By incorporating AI capabilities, you can empower your applications to not only process data but also learn from it, enabling them to make informed decisions.

Choosing the Right AI Libraries for C#

Before diving into development, it’s crucial to select the appropriate AI libraries and tools for your C# project. A popular choice is ML.NET, an open-source machine learning framework developed by Microsoft. Let’s take a look at a simple example of how to use ML.NET for sentiment analysis:

using Microsoft.ML;
using Microsoft.ML.Data;
using System;
public class SentimentData
{
 [LoadColumn(0)]
public string SentimentText;

 [LoadColumn(1), ColumnName("Label")]
public bool Sentiment;
}
public class SentimentPrediction : SentimentData
{
public float Score;
public float Probability;
public float PredictedLabel;
}
class Program
{
static void Main(string[] args)
{
var context = new MLContext();
// Load data
 var data = context.Data.LoadFromTextFile<SentimentData>("sentiment_data.csv", separatorChar: ',');
// Define pipeline
 var pipeline = context.Transforms.Text.FeaturizeText("Features", "SentimentText")
.Append(context.Transforms.CopyColumns("Label", "Sentiment"))
.Append(context.Transforms.NormalizeMinMax("Features"))
.Append(context.Transforms.Conversion.MapValueToKey("Label"))
.Append(context.Transforms.Concatenate("Features", "Features"))
.Append(context.Transforms.NormalizeMinMax("Features"))
.Append(context.Model.LoadTensorFlowModel("model.pb")
.ScoreTensorName("dense_2/Softmax")
.AddInput("conv1d_input", name => name == "conv1d_input")
.AddOutput("dense_2/Softmax")
)
.Append(context.Transforms.CopyColumns("Score", "PredictedLabel"));
// Train model
 var model = pipeline.Fit(data);
// Make predictions
 var predictionEngine = context.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
var sentimentData = new SentimentData { SentimentText = "This is great!" };
var prediction = predictionEngine.Predict(sentimentData);
Console.WriteLine($"Predicted Sentiment: {(prediction.Sentiment ? "Positive" : "Negative")}");
}
}

In this example, we use ML.NET to perform sentiment analysis on text data. The model is trained to predict whether a given text conveys a positive or negative sentiment.

Exploring NLP Capabilities in C#

Natural Language Processing (NLP) is a crucial component of many AI applications. With C#, you can leverage libraries like OpenNLP or integrate with Azure Cognitive Services for NLP tasks. Let’s look at a simple example of sentiment analysis using Azure Cognitive Services:

using Microsoft.Azure.CognitiveServices.Language.TextAnalytics;
using Microsoft.Azure.CognitiveServices.Language.TextAnalytics.Models;
class Program
{
static void Main(string[] args)
{
var client = new TextAnalyticsClient(new ApiKeyServiceClientCredentials("<YOUR_API_KEY>"))
{
Endpoint = "<YOUR_ENDPOINT>"
};
var sentiment = client.Sentiment("<YOUR_LANGUAGE>", new MultiLanguageInput
{
Id = "1",
Text = "This is great!"
});
Console.WriteLine($"Sentiment Score: {sentiment.Score}");
}
}

In this example, we utilise Azure Cognitive Services for sentiment analysis. The service provides a sentiment score, indicating the positivity or negativity of the provided text.

Real-world Applications and Beyond

These examples only scratch the surface of what’s possible when combining C# with AI. From recommendation systems to image recognition, the integration of AI expands the horizons of what your C# applications can achieve.

Conclusion

By integrating AI into your C# applications, you can create intelligent, data-driven solutions that excel in tasks ranging from sentiment analysis to complex machine learning models. With the right tools and techniques, your C# projects can leverage the power of AI to provide enhanced functionality and decision-making capabilities.

Setting Up Bitlocker With SSD/NVME Hardware Encryption (it can be faster than no encryption at all)

Tue, 24 Oct 2023 11:23:23 +0100

It has recently been reported that Windows 11’s default always-on bitlocker protection, with software encryption, could be crippling upto 45% of your storage performance.

To use Bitlocker with SSD Hardware full disk encryption, it’s crucial that your SSD supports TCG Opal and the eDrive standard (IEEE-1667). Unfortunately, many manufacturers omit this information from their datasheets, making it hard to find. To identify compatible devices with TCG Opal support, you can use the filter on the German Website Geizhals.

You will also require the manufacturer’s software for your SSD, such as Samsung Magician or Kingston’s SSD Manager.

Where to start

SSD Compatibility Check:
- Ensure your SSD supports TCG Opal and eDrive standard.
- Visit Geizhals for a filtered list of compatible devices.
Obtain Manufacturer’s Software:
- Download and install the specific software for your SSD (e.g., Samsung Magician or Kingston’s SSD Manager).
Windows 2 Go Installation (Optional but Recommended):
- Download the latest Windows ISO from Microsoft.
- Create a Windows 2 Go installation on a fast USB Stick, preferably NVME based, using Rufus.

What to do next

BIOS Configuration
- Install the SSD into the target computer.
- Disable the Compatibility Support Module (CSM) in the BIOS. This option is typically found in the BOOT settings, though it may be hidden if fast boot is enabled.
Boot into Windows Installation
- Boot into a Windows installation; ideally, use a USB Stick with Windows 2 Go.
SSD Software Component Installation:
- Install the SSD software component and locate the option to prepare the drive for encryption. In Samsung Magician, find it under “Data Management - Encrypted Drive,” while in Kingston’s SSD Manager, it’s called “IEEE 1667 Enable.”
Secure Erase:
- Perform a secure erase of the drive. You can do this directly in the tool or through BIOS options (found in the “Tools” section). Alternatively, you can use hdparm on Linux or diskpart on Windows.
Block SID Configuration:
- Disable “Block SID” in the BIOS alongside TPM configuration. If this option is not available in the BIOS, follow these steps in a Windows 2 Go installation:
  - Open Powershell as administrator.
  - Run: $tpm = gwmi -n root\cimv2\security\microsofttpm win32_tpm
  - Run: $tpm.SetPhysicalPresenceRequest(97)
- Reboot.
Complete Windows Installation:
- On the next boot, follow the prompts on the POST screen.
- Plug in your Windows installation stick and remove the Windows 2 Go stick.
- Press “F10” to accept the command, and the computer will reboot.
- Install Windows on the target SSD without accessing BIOS or Boot menu beforehand.
Enable Hardware-Based Encryption via Group Policy
- Open “group policies” via start.
- Navigate to Computer Configuration > Administrative Templates > Windows Components > Bitlocker > System Drive > Administrative Configure use of hardware-based encryption for fixed data drives.
- Activate the policy and disable fallback to software encryption in the lower left.
Encrypt System Drive:
- Open Bitlocker and initiate the encryption process for your system drive.
Optional Step (if “Block SID” config is persistent):
- If the POST screen indicates that the “Block SID” configuration is persistent, re-enable it either in the BIOS or via Windows Powershell:
  - Open Powershell as admin in Windows 2 Go.
  - Run: $tpm = gwmi -n root\cimv2\security\microsofttpm win32_tpm
  - Run: $tpm.SetPhysicalPresenceRequest(96)
- Reboot.
Enjoy better SSD performance… 😁

Best Practices for Exception Handling in C#

Wed, 18 Oct 2023 08:35:32 +0100

Exception handling is a critical aspect of robust software development. Properly managing exceptions ensures that your application can gracefully handle errors and recover from unexpected situations. In this article, we’ll explore the best practices for effective exception handling in C#.

Use Specific Exception Types

When catching exceptions, be specific about the type of exception you’re handling. This allows you to differentiate between different error scenarios and take appropriate actions.

try
{
// Code that may throw an exception
}
catch (ArgumentNullException ex)
{
// Handle ArgumentNullException
}
catch (InvalidOperationException ex)
{
// Handle InvalidOperationException
}

Avoid Catch-All Blocks

While it may be tempting to use a catch-all block (catching Exception), it’s generally better to handle specific exceptions. Catching all exceptions can mask unexpected errors and make debugging more challenging.

try
{
// Code that may throw an exception
}
catch (Exception ex)
{
// Avoid using a catch-all block unless absolutely necessary
}

Use Finally Blocks for Cleanup

The finally block is executed regardless of whether an exception is thrown. It’s ideal for releasing resources or performing cleanup operations.

try
{
// Code that may throw an exception
}
catch (Exception ex)
{
// Handle the exception
}
finally
{
// Cleanup code (e.g., closing files or connections)
}

Throw Exceptions with Meaningful Messages

When throwing exceptions, provide descriptive messages that help developers understand the cause of the error. This makes debugging and troubleshooting much easier.

if (input == null)
{
throw new ArgumentNullException(nameof(input), "Input cannot be null.");
}

Avoid Swallowing Exceptions

Avoid situations where exceptions are caught but not properly handled. If you can’t handle an exception at a certain level, it’s better to let it propagate up the call stack.

try
{
// Code that may throw an exception
}
catch (Exception ex)
{
// Don't just ignore the exception
 // Log it or rethrow if necessary
 Log.Error(ex.Message);
throw;
}

Use Custom Exceptions for Specific Cases

Creating custom exceptions can provide clarity about the nature of the error. It also allows you to add specific properties or methods relevant to your application.

public class CustomException : Exception
{
public CustomException(string message) : base(message) { }
// Additional custom properties or methods can be added here
}

Log Exceptions

Logging exceptions is crucial for debugging and monitoring the health of your application. Use a logging framework to record details about the exception, such as the message, stack trace, and context.

try
{
// Code that may throw an exception
}
catch (Exception ex)
{
Log.Error($"An error occurred: {ex.Message}", ex);
throw;
}

Conclusion

Effective exception handling is an integral part of writing reliable and maintainable code in C#. By following these best practices, you can build applications that gracefully handle errors, making them more robust and user-friendly. Remember, the goal is not just to catch exceptions, but to handle them in a way that promotes the stability and reliability of your software. Happy coding!

Effective Code Reviews in a Development Team

Tue, 17 Oct 2023 08:28:37 +0100

Code reviews are a crucial part of the software development process. They serve as a quality assurance measure, promote knowledge sharing, and enhance team collaboration. However, not all code reviews are equally effective. In this article, we’ll delve into the best practices for conducting productive and efficient code reviews within a development team.

Set Clear Objectives

Before diving into a code review, it’s important to define the specific goals and objectives. Are you primarily looking for bugs? Are you assessing adherence to coding standards? Clearly communicating the review’s purpose sets the right expectations for everyone involved.

Review Small Chunks of Code

Breaking down code into smaller, manageable chunks ensures that reviewers can focus on each piece effectively. It’s easier to catch errors and provide meaningful feedback when dealing with concise sections of code.

Automate What You Can

Automated tools and static code analyzers can catch many common issues, leaving more room for reviewers to focus on higher-level concerns. Use linters, code formatters, and other automated checks to streamline the review process.

Provide Constructive Feedback

When offering feedback, be specific and constructive. Point out what was done well, and suggest improvements where necessary. Avoid personal critiques and focus on the code itself.

Encourage Discussions, Not Arguments

Code reviews should be a collaborative effort. Encourage open discussions about the code. If there are disagreements, aim for a consensus rather than a winner-takes-all scenario. The goal is to improve the code, not to prove who’s right.

Follow Coding Standards and Guidelines

Consistency in code style and structure is crucial for maintainability. Establish clear coding standards and ensure that everyone on the team follows them. Code reviews are an excellent opportunity to reinforce these standards.

Balance Speed with Thoroughness

While it’s important to review code promptly, rushing through the process can lead to oversight. Strive for a balance between speed and thoroughness. Set realistic timeframes for reviews to maintain a steady development pace.

Track and Learn from Mistakes

Mistakes and oversights happen. Use them as learning opportunities. Implement measures to track and analyze the types of issues that arise during code reviews. This feedback loop can lead to process improvements over time.

Rotate Reviewers

Having different team members review code brings fresh perspectives and can uncover issues that might have been missed by others. It also spreads knowledge across the team, making everyone more familiar with the codebase.

Document and Archive Reviews

Keep records of code reviews for future reference. Documenting feedback and decisions can help with onboarding new team members, troubleshooting, and providing a historical context for code changes.

Conclusion

Effective code reviews are a cornerstone of successful software development teams. They foster a culture of continuous improvement, enhance code quality, and facilitate knowledge sharing. By following these best practices, your team can conduct code reviews that lead to better, more maintainable code.

Remember, code reviews are not just about finding bugs; they’re about making the entire development process more efficient and collaborative. Embrace them as an integral part of your team’s workflow. Happy reviewing!

Building a Cross-Platform Desktop App with .NET MAUI

Mon, 16 Oct 2023 09:22:56 +0100

.NET MAUI (Multi-platform App UI) is a powerful framework that empowers developers to build cross-platform applications with ease. In this article, we’ll guide you through the process of creating a desktop app using .NET MAUI.

What is .NET MAUI?

.NET MAUI is a modern, open-source UI framework from Microsoft that allows you to create applications for Android, iOS, macOS, and Windows from a single codebase. It leverages the power of Xamarin.Forms and extends it to cover more platforms.

Prerequisites

Before we dive in, make sure you have the following installed:

Visual Studio 2022 (or later)
.NET MAUI workload installed with Visual Studio.

Step 1: Creating a New .NET MAUI Project

Open Visual Studio and select “Create a new project.”
Choose “MAUI App” template and click “Next.”
Provide a project name and location, then click “Create.”

Step 2: Designing the User Interface

.NET MAUI uses XAML for designing user interfaces, making it easy to create visually appealing layouts. Add pages, controls, and customize properties using XAML markup.

Step 3: Writing Code in C#

Since .NET MAUI is based on .NET, you can use C# to implement the app’s logic. Utilize the power of C# to handle events, perform calculations, and interact with APIs.

Step 4: Handling Platform-Specific Code

.NET MAUI allows you to implement platform-specific code when needed. This ensures that your app can take full advantage of each platform’s unique capabilities.

if (Device.RuntimePlatform == Device.iOS)
{
// iOS-specific code
}
else if (Device.RuntimePlatform == Device.Android)
{
// Android-specific code
}
// Add more platform-specific code as needed

Step 5: Debugging and Testing

Use Visual Studio’s debugging tools to identify and fix issues in your code. Leverage the built-in emulator or connect physical devices for testing.

Step 6: Deploying Your App

Once your app is ready, it’s time to deploy it. .NET MAUI allows you to publish your app to various app stores or distribute it through other channels.

Conclusion

With .NET MAUI, building cross-platform desktop apps has never been easier. Its unified codebase, powerful UI capabilities, and support for platform-specific code make it a top choice for developers aiming to reach a broad audience. Start your .NET MAUI journey today and bring your ideas to life on Android, iOS, macOS, and Windows!

Remember, this is just the beginning. As you delve deeper into .NET MAUI, you’ll discover even more features and capabilities that will help you create truly exceptional cross-platform desktop applications.

Efficient Debugging with Visual Studio

Sat, 14 Oct 2023 09:00:00 +0100

Debugging in C# is not about removing bugs; it’s the process of understanding and isolating them before removing them.

In the world of C# development, debugging is akin to being a detective. It’s the skill that separates a good developer from a great one. No matter how skilled you are in writing code, bugs are inevitable companions in the journey of software creation. In this article, we’ll explore the art of debugging in C#, uncovering techniques that can streamline your problem-solving process and lead to more efficient, error-free code, with the help of Visual Studio.

Understanding the Debugging Mindset

Before diving into specific techniques, it’s crucial to adopt the right mindset when approaching debugging:

Patience is a Virtue

Debugging can be a time-consuming process. It’s important to approach it with patience and persistence. The most elusive bugs often require careful examination and creative thinking.

Isolation and Reproducibility

The first step in debugging is isolating the problem. Reproduce the issue in a controlled environment. This ensures you’re working with a consistent set of circumstances, making it easier to identify the root cause.

Documentation is Key

Keep detailed records of your debugging process. Note what you’ve tried, what worked, and what didn’t. This serves as a valuable resource for future debugging endeavors.

Techniques for Efficient Debugging in C#

Print Debugging in C# with Console.WriteLine()

One of the oldest and most straightforward methods in C# is print debugging. It involves strategically placing Console.WriteLine() statements in your code to output relevant information. This can help track the flow of execution and identify unexpected behaviors.

public int MyFunction(int arg)
{
Console.WriteLine($"arg: {arg}"); // Add print statements
 int result = arg * 2;
Console.WriteLine($"result: {result}"); // Add print statements
 return result;
}

Utilize Visual Studio’s Debugging Tools

Visual Studio provides powerful debugging tools for C# development. These tools allow you to set breakpoints, inspect variables, and step through your code line by line. Familiarize yourself with the debugging features of Visual Studio for a more efficient debugging experience.

Rubber Duck Debugging in C#

Sometimes, the act of explaining the problem to someone (or something) else can lead to a breakthrough. This is the essence of rubber duck debugging. Simply verbalizing the issue can provide new insights and perspectives.

4. Binary Search Method in C#

If dealing with a large codebase, the binary search method can be incredibly efficient in C#. Divide the code in half and determine which half contains the bug. Continue narrowing down until you’ve pinpointed the problematic section.

Code Review and Pair Programming in C#

Another set of eyes can be invaluable in the debugging process in C#. A fresh perspective might catch something you’ve overlooked. Code reviews and pair programming can uncover issues early in the development process.

Regression Testing in C#

If you’ve fixed a bug in C#, it’s essential to ensure that the fix hasn’t introduced new issues. Regression testing involves re-running previous tests to confirm that existing functionality remains intact.

Conclusion

Debugging in C# with Visual Studio is a skill that grows with experience. The more you encounter and resolve bugs, the more adept you become at spotting and solving them. Remember, it’s not just about fixing the immediate issue, but also about understanding why it occurred in the first place. With practice and the right mindset, you’ll master the art of debugging and become a more proficient C# developer in Visual Studio.

So, the next time you encounter a bug, don your detective hat, and embark on the exhilarating journey of debugging in C#! Happy coding!

Unit Testing vs Manual Testing

Fri, 13 Oct 2023 22:24:09 +0100

Selecting the right testing methodology can significantly impact the quality and reliability of your code. Two primary approaches, unit testing and manual testing, each have their strengths and are best applied in specific scenarios. Understanding when to employ each method is crucial for achieving a well-rounded testing strategy.

Unit Testing: Precision in Isolation

Unit testing involves the examination of individual units or components of a software application to validate their correctness. These units are typically functions, methods, or classes. The key advantages of unit testing include:

Early Bug Detection: Unit tests catch defects in the early stages of development, reducing the cost and effort required to rectify them.
Maintainable Codebase: They serve as documentation for how code is intended to be used, enhancing code comprehension and maintainability.
Regression Safety Net: Unit tests provide a safety net when making changes or adding new features, ensuring existing functionality remains intact.
Design Improvement: Writing unit tests promotes modular, loosely-coupled code, leading to better software architecture.
Confident Refactoring: Developers can make significant changes to the codebase with confidence, knowing that they will be alerted if anything breaks.

Best Use Cases for Unit Testing in C#

Business Logic: Verify the correctness of algorithms, calculations, and data manipulations.
Isolated Functions/Methods: Test functions or methods that don’t rely heavily on external dependencies.
Core Libraries and Frameworks: Ensure that foundational components function as expected.

Manual Testing: The Human Touch

Manual testing involves human intervention to evaluate an application’s functionality, usability, and overall user experience. This approach is essential for aspects that automated tests might not cover. The key advantages of manual testing include:

User Experience Assessment: Testers provide insights into the user-friendliness and intuitiveness of the software, identifying areas for improvement.
Exploratory Testing: Testers creatively explore the application, simulating real-world usage scenarios.
Non-Functional Testing: Performance, security, and compatibility testing are areas where manual testing shines.
Ad-Hoc Testing: Identifying unexpected issues that automated tests may not account for.
Usability Testing: Evaluating how user interfaces and interactions align with user expectations.

Best Use Cases for Manual Testing in C#

User Interface (UI) Testing: Evaluate the user interface for intuitiveness, responsiveness, and visual consistency.
User Experience (UX) Evaluation: Assess how the software aligns with user expectations and ease of use.
Security and Compliance Testing: Identify vulnerabilities, compliance with industry standards, and data protection measures.
Load and Performance Testing: Simulate real-world usage scenarios to evaluate system response under stress.
Compatibility Testing: Verify that the software functions correctly across different platforms and devices.

Balancing Unit and Manual Testing

The optimal testing strategy often involves a blend of both unit and manual testing. They complement each other, covering different aspects of testing. Unit tests ensure precise functionality, while manual tests offer a human perspective on user experience and non-functional aspects.

By strategically applying unit and manual testing in C# development, you can elevate the quality and reliability of your software, providing users with a seamless and robust experience. Remember, the choice between these testing approaches should be based on the specific requirements and objectives of your project.

Essential Things Every Professional Software Developer Should Know

Fri, 06 Oct 2023 09:34:35 +0100

Greetings, aspiring software developers! As you embark on the path of professional software development, it is imperative to equip yourself with a solid foundation in key principles. Whether you are a seasoned coder or just beginning your journey, these fundamental concepts will serve as your guiding light in this dynamic field. Let’s delve into the essentials.

Master Your Coding Arsenal

Start by getting familiar with your chosen programming language(s) and the tools of the trade. For web developers, this typically involves languages like HTML, CSS, and JavaScript. If you’re venturing into AI, Python might be your go-to language.

Learn more: Choosing the Right Programming Language

Unleash Your Inner Problem-Solver

Software development is akin to solving a puzzle. You need to approach problems with a structured, algorithmic mindset. Break down complex issues into manageable steps, and you’re well on your way!

Learn more: How to Think Like a Programmer

Dance with Data Structures and Algorithms

These are the backbone of any skilled coder. Arrays, linked lists, trees - make them your companions. Additionally, befriend sorting and searching algorithms; they’ll serve you well.

Learn more: Data Structures and Algorithms Crash Course

Navigate the Software Development Life Cycle (SDLC)

Understanding how software evolves, from inception to coding, testing, and launch, is essential. Familiarise yourself with the Software Development Life Cycle to witness the magic unfold.

Learn more: Understanding the Software Development Lifecycle

Talk the Talk and Walk the Walk

In the world of code, effective communication is paramount. Whether you’re explaining a complex concept to a non-techie or collaborating with your team, being a great communicator sets you apart.

Learn more: 10 Communication Skills Every Developer Should Master

Lock Down Your Code Fort

Security is paramount. Familiarise yourself with secure coding practices, robust authentication methods, and how to safeguard your code from malicious intent.

Learn more: OWASP Secure Coding Practices

Need for Speed? Optimise Your Code

Efficiency matters. Learn how to optimise your code for speed and performance. Profiling tools and optimization techniques should be in your toolkit.

Learn more: Writing High-Performance Code

Put Your Code to the Test

Thorough testing is a cornerstone of robust code. Master writing tests and using testing frameworks to ensure your code stands up to scrutiny.

Learn more: Software Testing Fundamentals

Git Gud with Version Control

Version control, facilitated by tools like Git and platforms like GitHub, is the linchpin of collaborative development. Familiarise yourself with branching, merging, and conflict resolution.

Learn more: Learn Git Branching

Automate All the Things with CI/CD!

CI/CD pipelines are your ticket to streamlined development. Learn how to automate your builds and deployments for a smoother coding experience.

Learn more: Introduction to CI/CD

Comparing GraphQL and OData: Which is Best and When?

Thu, 05 Oct 2023 10:24:40 +0100

In the realm of API query languages, GraphQL and OData stand out as powerful tools that facilitate data retrieval and manipulation. While both serve similar purposes, they exhibit distinct characteristics that cater to different use cases and development paradigms. In this article, we’ll delve into the key differences and similarities between GraphQL and OData, supported by examples to illustrate their unique features.

Similarities

Query Language for APIs: Both GraphQL and OData serve as query languages for APIs, enabling clients to request specific data from a server.
Flexibility: Both allow clients to specify exactly which fields they want to retrieve, reducing over-fetching of data and improving performance.
Hierarchical Structure: Both follow a hierarchical structure, making it easy to navigate and request related data.

Differences:

Schema Definition

GraphQL requires the explicit definition of a schema, which outlines the types of data that can be queried.
```
type User {
id: ID!
name: String!
email: String!
}
type Query {
user(id: ID!): User
}
```

OData uses the Entity Data Model (EDM) to define the data model, including entities and relationships.

<EntityType Name="User">
<Key>
<PropertyRef Name="Id" />
</Key>
<Property Name="Id" Type="Edm.Int32" Nullable="false" />
<Property Name="Name" Type="Edm.String" />
<Property Name="Email" Type="Edm.String" />
</EntityType>

Query Language
- GraphQL uses a specific query language that allows clients to request exactly what they need.
```
query {
user(id: "1") {
name
email
}
}
```
- OData relies on URL conventions for querying data
```
GET /Users(1)?$select=Name,Email
```
Complex Queries
- GraphQL excels at handling complex queries, allowing clients to traverse deeply nested data structures.
```
query {
user(id: "1") {
name
posts {
title
comments {
text
}
}
}
}
```
- OData supports complex queries, but it may require more verbose URLs.
```
GET /Users(1)?$expand=Posts($expand=Comments($select=Text)),Name,Email
```
Filtering and Sorting
- GraphQL typically requires custom resolver logic for filtering and sorting
```
query {
users(filter: {name_contains: "John"}, orderBy: "name") {
name
email
}
}
```
- OData provides built-in query options for filtering, sorting, and paging.
```
GET /Users?$filter=contains(Name,'John')&$orderby=Name asc
```
Metadata
- GraphQL does not have built-in metadata endpoints
- OData exposes metadata, allowing clients to dynamically discover the structure of the API.
```
GET /$metadata
```
Batch Operations
- GraphQL does not have built-in support for batch operations
- OData supports batch requests, allowing multiple operations to be grouped into a single HTTP request
```
POST /$batch
```

When to Use GraphQL:

Complex Data Relationships: Use GraphQL when dealing with complex relationships between data entities, as it allows for efficient traversal of nested data structures.
Frontend-Driven Development: GraphQL is an excellent choice when the frontend team has a strong influence on data requirements, as it enables them to request exactly the data they need.
Real-Time Data Needs: If real-time data updates are crucial, GraphQL subscriptions provide a powerful mechanism for real-time data synchronization between the server and clients.
Single Page Applications (SPAs): For SPAs where optimizing network requests is crucial, GraphQL can reduce over-fetching of data, improving performance.
Microservices Architecture: GraphQL is well-suited for microservices environments, where different services may expose different types of data, allowing clients to aggregate information efficiently.
Mobile Applications: In mobile applications, where minimizing data transfer is critical for performance and battery life, GraphQL’s fine-grained control over data retrieval is advantageous.

When to Use OData

Enterprise-Level Applications: In large enterprise applications with existing OData services or legacy systems that support OData, it may be more straightforward to continue using OData.
Query Optimization and Caching: OData’s query options for filtering, sorting, and paging can be highly efficient, especially when working with large datasets. Additionally, caching can be effectively implemented.
Metadata-Driven Development: OData’s metadata capabilities are valuable when dynamic discovery of API structure is needed.
Batch Operations: In scenarios where batch operations are essential, OData provides built-in support, simplifying complex data operations.
Strongly-Typed Environments: In environments where a strongly-typed data model is preferred, OData’s use of the Entity Data Model (EDM) aligns well with this paradigm.
Existing OData Ecosystem: When integrating with existing systems, services, or ecosystems that already support OData, it makes sense to continue using OData to leverage existing infrastructure.

Choosing the Right Tool

Ultimately, the choice between GraphQL and OData depends on various factors including project requirements, team expertise, and existing infrastructure. It’s essential to evaluate the specific needs of the application and consider how each technology aligns with those needs. Additionally, hybrid approaches are also feasible, where GraphQL and OData can be used in different parts of an application to leverage the strengths of both.

Why Your Language Choice Doesn't Matter as Good Programmer

Tue, 03 Oct 2023 09:26:20 +0100

In the world of coding, there’s often a lively debate about which programming language reigns supreme. However, the real measure of a top-notch programmer isn’t their expertise in just one language, but their knack for seamlessly shifting between them. In this article, we’ll explore why it’s more important for a skilled coder to be adaptable rather than fixated on a single language.

Grasping the Core Ideas

A good programmer knows that the heart of coding—things like how data’s organized, strategies for solving problems, and the building blocks of software—are universal. These principles aren’t confined to a particular language; they form the bedrock on which all programming languages are built. By mastering these basics, a seasoned coder can easily apply their knowledge to any language.

Picking the Right Tool for the Job

Different languages have different strengths and are best suited to particular tasks. For instance, Python’s fantastic for number crunching and machine learning, while C++ is a champ in low-level system work. A savvy programmer understands the importance of choosing the right language for the job, instead of trying to force a solution into a language that might not be the best fit.

Being Adaptable Shows True Skill

Being good at multiple programming languages is a testament to a programmer’s ability to adapt and be versatile. It’s a sign of someone who can learn fast, think critically, and tackle problems with finesse. This adaptability goes beyond just languages; it extends to being comfortable with different development tools, frameworks, and environments.

Boosting Your Career and Appeal to Employers

In the job market, being a flexible programmer is what you need. Employers highly value developers who can smoothly transition between projects, technologies, and languages. This adaptability lets businesses respond swiftly to changing project needs and industry trends.

Learning New Languages Becomes a Breeze

Once you’ve got the core concepts of programming down, picking up a new language is mainly about getting the hang of its style and idioms. This process is much smoother for a programmer who’s already worked with a variety of languages. It’s like being fluent in several spoken languages; once you know how to learn a language, picking up new ones becomes second nature.

Avoiding Stubbornness, Welcoming Practicality

Getting too attached to one language can cause stubbornness, where a programmer insists on using their favorite language even when it might not be the best fit for a particular project. This rigid mindset can slow progress and stifle innovation. A wise programmer is practical, recognizing that the best solution might call for adopting a different language.

Conclusion

In software development, the ability to adapt in different coding environments is what sets a skilled programmer apart from the rest. By focusing on core concepts, choosing the right tool for each job, and being open to learning new languages, programmers can unlock new opportunities, enhance their appeal to employers, and ultimately become more effective and versatile developers. Remember, it’s not about the language you use, but how skillfully you use it.

Choosing the Right IDE: Visual Studio vs. JetBrains Rider

Tue, 03 Oct 2023 08:49:00 +0100

When it comes to software development, the choice of Integrated Development Environment (IDE) can greatly influence productivity and code quality. Two heavyweights in the IDE arena are Microsoft’s Visual Studio and JetBrains' Rider. In this article, we’ll delve into the strengths and weaknesses of each, helping you make an informed decision for your next project.

Visual Studio: The Microsoft Powerhouse

Pros

Wide Ecosystem
- Visual Studio boasts extensive language and platform support, from C# and .NET to Python and JavaScript. This versatility makes it an attractive choice for developers working in various tech stacks.
Intuitive Interface
- The IDE’s user-friendly interface is designed for smooth navigation and a comfortable coding experience. This helps developers focus on writing quality code rather than struggling with the environment.
Strong Microsoft Integration
- If your project is firmly rooted in the Microsoft ecosystem, Visual Studio is the natural choice. It seamlessly integrates with Azure, SQL Server, and other Microsoft technologies, streamlining the development process.
Powerful Debugging Tools
- Visual Studio sets the bar high with its robust debugging capabilities. Features like live debugging, IntelliTrace, and Performance Profiler empower developers to efficiently identify and squash bugs.
Rich Plugin Ecosystem
- The Visual Studio Marketplace offers an extensive library of extensions. This allows developers to customize and extend the IDE’s functionality to suit their specific needs.

Cons

Resource Intensive
- On the flip side, Visual Studio can be resource-intensive, especially for larger projects. This may lead to slower performance on less powerful machines, necessitating higher hardware requirements.
Limited Cross-platform Support
- While versatile, Visual Studio might not be the go-to choice for developers heavily invested in cross-platform development compared to some other IDEs.

JetBrains Rider: A Cross-Platform Marvel

Pros

Cross-platform Support
- Rider is a cross-platform champion, designed to seamlessly run on Windows, macOS, and Linux. This flexibility accommodates teams with diverse operating system preferences.
Intelligent Code Assistance
- Rider stands out with its intelligent code completion, inspections, and refactoring tools. These features enhance productivity by streamlining the development workflow.
Multi-language Support
- Beyond its proficiency in C# and VB.NET, Rider extends its support to a wide array of languages including JavaScript, TypeScript, HTML, CSS, and more. This makes it a versatile choice for polyglot developers.
Smooth Integration with JetBrains Tools
- Rider harmonizes effortlessly with other JetBrains tools such as ReSharper for C# and WebStorm for web development. This tight integration augments the IDE’s capabilities.
Efficient Performance and Memory Management
- One of Rider’s standout features is its efficiency in terms of memory usage. This leads to snappier performance, particularly on less powerful hardware configurations.

Cons

Learning Curve
- For developers new to JetBrains IDEs, there might be a learning curve in getting accustomed to the interface and workflow. However, the investment is well worth the productivity gains in the long run.
Plugin Ecosystem
- While Rider has a commendable selection of plugins, it may not rival Visual Studio’s extensive library. Nevertheless, it covers the essentials and offers a solid foundation for customization.

Conclusion: The Right Tool for the Right Job

Ultimately, the choice between Visual Studio and JetBrains Rider hinges on your specific needs, preferences, and the nature of your development work. Both IDEs are formidable contenders, widely embraced by developers across the industry. So, rest assured, you’re in capable hands no matter which one you choose. Happy coding!

Embracing TypeScript: The Advantages Over Raw JavaScript

Mon, 02 Oct 2023 08:41:59 +0100

JavaScript has been the backbone of web development for decades, enabling dynamic and interactive web applications. However, as web projects grow in size and complexity, so do the challenges of managing code quality and catching potential bugs. Enter TypeScript, a superset of JavaScript that adds static typing and advanced tooling to the mix. In this article, we’ll explore why developers should consider using TypeScript over raw JavaScript for their projects.

Strong Typing for Enhanced Safety

One of the most compelling reasons to use TypeScript is its strong typing system. This allows developers to specify the type of data that variables, parameters, and functions can hold. This leads to fewer runtime errors and better code quality, as type-related issues are caught during development rather than at runtime.

function greet(name: string) {
return `Hello, ${name}!`;
}
const message = greet(42); // Error: Argument of type '42' is not assignable to parameter of type 'string'.

Improved Code Maintainability

As projects scale, maintaining a clear understanding of variable types and function signatures becomes increasingly challenging in JavaScript. TypeScript’s static type annotations serve as documentation that can be utilized by developers and IDEs to provide context and suggest appropriate completions. This makes it easier to navigate and understand large codebases.

Enhanced IDE Support and Tooling

TypeScript provides powerful tooling and IDE support. Popular editors like Visual Studio Code, WebStorm, and others offer extensive TypeScript integration, including features like autocompletion, refactoring tools, and immediate feedback on potential type errors. This not only boosts productivity but also helps catch and fix issues early in the development process.

Better Collaboration in Teams

In larger development teams, where multiple developers may be working on different parts of a codebase simultaneously, TypeScript helps facilitate smoother collaboration. With explicit type annotations, it’s easier for team members to understand each other’s code and integrate their work seamlessly.

Enables More Robust Testing

Static typing is a powerful ally in testing. It allows for more accurate and efficient unit testing as developers can be sure that their functions receive and return the expected types of data. This leads to more effective testing strategies and helps prevent common runtime errors.

Reduced Debugging Time

TypeScript significantly reduces the time spent debugging runtime errors caused by type mismatches or undefined variables. The compiler catches many of these issues before the code even runs, leading to faster development cycles and more reliable applications.

Conclusion

While JavaScript is a versatile language, TypeScript offers a powerful set of tools and features that can significantly improve the development process. From enhanced safety through static typing to improved maintainability, TypeScript has become a go-to choice for many developers working on modern web projects. By adopting TypeScript, developers can write more reliable, maintainable, and scalable code, ultimately leading to better user experiences and more robust applications.

Evaluating Go: Why It Might Not Always Be a Suitable Replacement for C++

Sun, 01 Oct 2023 08:12:53 +0100

Go, also known as Golang, has surged in popularity for its simplicity, efficiency, and concurrency model. While it excels in certain domains, it may not always be the optimal choice for replacing C++. In this article, we’ll delve into some of the reasons why Go might not be the perfect substitute for C++.

Lack of Low-Level Capabilities

C++ is renowned for its ability to work at a low-level, allowing for fine-grained control over system resources. Go, on the other hand, is designed with simplicity in mind, sacrificing some low-level capabilities. This can be a limiting factor in scenarios that require intricate memory management or direct hardware interaction, such as device drivers or embedded systems development.

Limited Language Features

Go deliberately omits certain features found in languages like C++. It lacks generics, which can result in code duplication or less reusable components. Additionally, Go’s lack of operator overloading and its minimalist approach to object-oriented programming may be a stumbling block for developers accustomed to C++’s more expressive syntax.

Limited Support for GUI Development

C++ has a rich history of GUI development, with libraries like Qt and GTK providing robust solutions. Go, however, has a more nascent ecosystem in this regard. While there are libraries available for GUI development in Go, they may not offer the same level of maturity and feature set as their C++ counterparts.

Performance Overheads

Go’s garbage collector, while efficient for many applications, can introduce non-deterministic delays in real-time or performance-critical systems. In contrast, C++ allows for explicit memory management, giving developers more control over performance optimizations. This can be a crucial consideration in domains where predictable performance is paramount.

Limited Support for Native Libraries

C++ has a seamless integration with C, allowing for direct use of native libraries and system APIs. Go, while it provides mechanisms for interfacing with C code, may require additional effort to interact with existing C or C++ libraries. This can be a significant hurdle for projects that heavily rely on established C++ libraries or have dependencies on native system interfaces.

Maturity and Ecosystem

C++ has a decades-long history and a mature ecosystem with a vast array of libraries, frameworks, and tools. Go, while growing rapidly, may not have the same level of diversity and depth in its ecosystem. This can be a critical factor for projects that rely heavily on third-party libraries or need access to a wide range of specialised tools.

In summary, while Go has many merits and excels in certain areas, it is not always a direct replacement for C++. It’s essential to carefully evaluate the specific requirements and constraints of a project before deciding on a programming language. In some cases, the unique strengths of C++, such as low-level capabilities and a mature ecosystem, may outweigh the benefits of Go’s simplicity and efficiency. The choice between C++ and Go should be driven by a thorough understanding of the project’s needs and the strengths of each language.

Debunking the Rust Hype: Why It's Not Always a Good Replacement for C++

Sat, 30 Sep 2023 08:10:13 +0100

In recent years, Rust has gained significant attention and popularity in the programming community. Advocates often tout it as a worthy successor to C++, promising safer and more efficient systems programming. While Rust certainly has its merits, it’s essential to recognise that it may not always be the best fit for every scenario. In this article, we’ll explore some of the reasons why Rust may not necessarily be a superior replacement for C++.

Learning Curve

One of the most significant challenges when adopting Rust is its steep learning curve. C++ developers, especially those with extensive experience, might find it particularly challenging to transition to Rust due to its unique ownership model and strict borrowing rules. This can result in a considerable investment of time and resources in retraining existing teams or hiring new ones proficient in Rust.

Mature Ecosystem

C++ has a well-established and extensive ecosystem of libraries, frameworks, and tools that have evolved over decades. In contrast, Rust’s ecosystem is still relatively young and may not offer the same breadth and depth of resources. For specialised domains or legacy systems, finding equivalent Rust libraries or tools can be a daunting task, potentially leading to project delays or compromises in functionality.

Performance Trade-offs

While Rust’s emphasis on safety is commendable, it comes at a cost. The strict ownership model and borrow checker can introduce overhead, impacting runtime performance compared to C++. In scenarios where raw performance is paramount, such as real-time systems or high-frequency trading applications, C++ may still hold a distinct advantage.

Lack of Legacy Code Compatibility

For projects with existing codebases in C++ or interdependent legacy systems, migrating to Rust might not be a straightforward process. Rewriting or retrofitting existing code to work with Rust’s ownership model can be a substantial undertaking, potentially outweighing the benefits gained from Rust’s safety guarantees.

Resource Constraints

In certain resource-constrained environments, such as embedded systems or IoT devices with limited memory and processing power, Rust’s runtime and memory management system may not be the most efficient choice. C++ provides more fine-grained control over memory allocation and deallocation, allowing for optimization in resource-constrained environments.

Industry Adoption and Support

C++ has been a cornerstone of system-level programming for decades and is deeply entrenched in many critical industries, including aerospace, gaming, finance, and telecommunications. The vast majority of existing codebases in these sectors are written in C++. The risk and cost associated with a wholesale transition to Rust, both in terms of retraining personnel and rewriting existing code, may not be justified by the perceived benefits.

In conclusion, while Rust brings significant advancements in safety and memory management to the table, it is not a one-size-fits-all replacement for C++. It’s crucial to assess the specific needs and constraints of a project before making a decision. In some cases, the benefits of adopting Rust may be outweighed by the challenges and costs associated with the transition. Ultimately, the choice between C++ and Rust should be driven by a thorough evaluation of the project’s requirements and the strengths of each language.

Unraveling the Causes of Burnout in Software Developers and Strategies for Prevention

Fri, 29 Sep 2023 08:45:04 +0100

In the fast-paced world of software development, burnout has become an alarming concern. Long hours, high pressure, and relentless deadlines can take a toll on even the most dedicated professionals. In this article, we’ll explore the root causes of burnout in software developers and provide actionable strategies to help prevent it.

Understanding Burnout

Burnout is a state of chronic physical and emotional exhaustion, often accompanied by cynicism and detachment from work. It’s a result of prolonged exposure to stressors, which can lead to feelings of hopelessness and reduced efficiency.

Causes of Burnout in Software Developers

Excessive Workload

One of the primary contributors to burnout is an overwhelming workload. Developers often face tight project deadlines and an ever-expanding list of tasks, leaving little room for breaks or personal time.

Lack of Autonomy

When developers are micromanaged or have little say in the decision-making process, it can lead to a sense of frustration and helplessness. Autonomy is crucial for job satisfaction and a sense of ownership in one’s work.

Unclear Expectations

Unclear or constantly changing project goals, requirements, or expectations can create a sense of chaos and instability, leading to stress and burnout.

Inadequate Resources

Insufficient tools, outdated technology, or a lack of necessary resources can hinder a developer’s ability to perform their job effectively. This can lead to increased frustration and a diminished sense of accomplishment.

Perpetual Crunch Time

Frequent periods of “crunch time” or sustained overtime can be detrimental to both physical and mental well-being. While short bursts of intense work may be necessary, prolonged periods can lead to burnout.

Lack of Recognition

A lack of acknowledgment or appreciation for a developer’s hard work can lead to feelings of undervaluation, which can contribute to burnout.

Isolation

Working in isolation, whether due to remote work arrangements or an isolated workspace, can lead to feelings of loneliness and detachment, which can exacerbate burnout.

Strategies to Prevent Burnout

Set Realistic Expectations

Clear, achievable goals and deadlines are essential. Avoid overloading developers with an unrealistic amount of work.

Foster Autonomy

Encourage decision-making and provide opportunities for developers to have a say in the projects they work on. This fosters a sense of ownership and responsibility.

Provide Adequate Resources

Ensure developers have access to the necessary tools, technology, and training to perform their jobs effectively. Up-to-date resources can streamline workflows and increase efficiency.

Promote Work-Life Balance

Encourage regular breaks and time off. Discourage excessive overtime and ensure that employees have time to rest and recharge.

Recognize and Celebrate Achievements

Acknowledge and celebrate the achievements and contributions of developers. Recognition can boost morale and motivate continued high-quality work.

Foster a Supportive Work Environment

Encourage open communication, collaboration, and camaraderie among team members. This can help combat feelings of isolation and promote a positive work culture.

Provide Opportunities for Skill Development

Invest in the professional growth of developers by offering opportunities for training, conferences, and skill-building activities. This not only enhances their capabilities but also demonstrates a commitment to their success.

Conclusion

Preventing burnout in software developers requires a proactive and holistic approach. By addressing the root causes and implementing strategies to support the well-being and professional growth of developers, organizations can create a more sustainable and fulfilling work environment. Remember, a healthy and motivated team is key to achieving long-term success in the ever-evolving field of software development.

Embracing Efficiency: Shorter Work Hours for Software Developers (And everyone else)

Thu, 28 Sep 2023 09:24:41 +0100

In todays world, productivity is the name of the game, especially in the tech industry where software developers are the driving force behind innovation. However, the idea that longer hours lead to greater productivity is no longer considered to be the case by most. Recent research and real-world examples suggest that cutting back on work hours can actually boost productivity for software developers. In this article, we’ll explore the reasons behind this shift and the benefits it brings to both developers and their employers.

The Law of Diminishing Returns

Think of it as the law of productivity. Beyond a certain point, putting in extra hours doesn’t necessarily translate to a proportional increase in output. In fact, it can lead to burnout and a dip in the quality of work. By opting for shorter workdays, developers can maintain a higher level of focus and creativity throughout their work hours, resulting in more productive output.

Parkinson’s Law: Work Expands to Fill the Time Available

According to Parkinson’s Law, work tends to expand to fit the time allotted for its completion. This means if developers have more time than they actually need for a task, efficiency might take a hit. Shorter work hours create a sense of urgency, encouraging developers to work more efficiently within the allotted time.

Balancing Work and Life

A balanced work-life equation is essential for sustained productivity. When employees are overworked, it leads to increased stress, lower morale, and a higher chance of turnover. Offering shorter work hours shows a commitment to employees' well-being, creating a positive work environment, reducing turnover, and attracting top talent.

Sharper Focus and More Creativity

Long working hours can lead to mental fatigue, which can stifle creativity and problem-solving abilities. A reduction in working hours lets developers approach tasks with renewed focus and a fresh perspective, resulting in more innovative solutions and quicker development cycles.

Optimised Time Management

Shorter work hours encourage better time management. Knowing they have limited hours encourages developers to prioritise tasks and approach assignments with more determination. This often leads to a more organised and streamlined workflow.

Prioritizing Health and Well-being

Physical and mental well-being are essential for sustained productivity. Longer working hours can lead to health issues, both physical and psychological. By reducing working hours, employers contribute to the overall health and well-being of their workforce. Healthy, well-rested employees are more likely to perform optimally, leading to fewer sick days and increased job satisfaction.

Continuous Growth and Learning

In the ever-evolving tech industry, ongoing learning and skill development are vital. Fewer working hours give developers more time for personal and professional growth. This might involve pursuing additional certifications, attending workshops, or engaging in side projects. It’s a win-win, benefiting both the developer and the company by keeping skills up-to-date and relevant.

Boosted Motivation and Engagement

Knowing they have a more manageable workload, developers are likely to approach their tasks with increased motivation and enthusiasm. This often leads to higher levels of engagement with their work, resulting in higher-quality output.

Advocating for Shorter Work Hours

As employees, it’s essential to recognise the benefits of shorter work hours. If you believe this approach could enhance productivity in your workplace, consider initiating a conversation with management. Presenting the evidence and making a case for more efficient work hours can lead to a more productive and fulfilling work environment for everyone involved. Remember, it’s a step towards a healthier, more balanced, and ultimately more successful work culture.

Mental Health in Tech: Prioritizing Employee Wellbeing for Enhanced Productivity

Wed, 27 Sep 2023 08:00:13 +0100

In the fast-paced world of technology, where lines of code and lines of communication intersect, there’s a silent but significant force driving innovation – the mental wellbeing of tech professionals. Balancing the demands of a constantly evolving industry with personal wellness can be a formidable challenge. Yet, it’s a challenge that must be met head-on for the sake of both employees and the companies they serve.

A Balancing Act

In the realm of technology, the pressure to stay ahead of the curve is relentless. New languages, frameworks, and methodologies emerge almost as quickly as the latest meme on social media. In this environment, it’s easy to overlook the crucial role that mental health plays in sustaining a thriving workforce.

Tech professionals are no strangers to the pressures of tight deadlines, demanding clients, and the pursuit of perfection. These stressors, when left unchecked, can lead to burnout and a decline in overall productivity. Recognizing the signs of stress and providing resources for self-care is not just a nice gesture; it’s an investment in the longevity and vitality of your team.

Breaking the Stigma

In the tech world, there’s often an unspoken expectation of perpetual productivity. Long hours, late-night coding sessions, and constant connectivity can become the norm. However, it’s crucial to challenge this mindset and create an environment where mental health is openly acknowledged and prioritized.

Encouraging open conversations about mental health is the first step. When employees feel safe discussing their struggles, it fosters a culture of empathy and support. Simple gestures like regular check-ins, wellness programs, and access to mental health resources can make a world of difference.

The Ripple Effect

Prioritizing mental health isn’t just about individual wellbeing; it’s about the collective strength of a team. When employees feel supported and valued, they’re more likely to be engaged and motivated. This leads to increased creativity, higher job satisfaction, and ultimately, enhanced productivity.

Furthermore, a mentally healthy workforce can serve as a powerful recruitment tool. Top talent is drawn to companies that demonstrate a genuine commitment to the wellbeing of their employees. By embracing mental health as a cornerstone of company culture, tech firms can attract and retain the best and brightest in the industry.

Embracing Flexibility

In a world where remote work has become the new norm, it’s essential to recognize the benefits of flexibility for mental health. Allowing employees to structure their workdays in a way that aligns with their individual needs can lead to a more balanced and fulfilled workforce.

Flexibility also extends to providing opportunities for skill-building and career growth. Investing in personal development not only enhances employees' confidence and job satisfaction but also contributes to a positive and forward-thinking work environment.

The Future of Tech and Wellbeing

As technology continues to revolutionize industries and reshape the way we live and work, it’s imperative that we don’t lose sight of our most valuable resource – the people behind the screens. Prioritizing mental health in tech isn’t just a feel-good initiative; it’s a strategic imperative that can drive innovation, foster resilience, and ultimately lead to greater success.

In this dynamic landscape, let’s remember that the wellbeing of our employees is not a checkbox on a to-do list, but a foundation upon which a thriving tech ecosystem can be built. By nurturing the mental health of our teams, we’re not only investing in their future but also in the future of technology itself. Together, we can forge a path that leads to innovation, productivity, and a more compassionate tech industry for all.

Enhancing Unity Game Performance with Universal Render Pipeline (URP)

Tue, 26 Sep 2023 10:35:44 +0100

The Universal Render Pipeline (URP) is a powerful tool that can significantly improve the performance of your Unity game. By leveraging its features and implementing optimisation techniques, you can create a smoother and more responsive gaming experience. In this article, we’ll explore key strategies for performance tuning in Unity games using the URP pipeline. When I started using unity, I had no idea what it was that I was missing, so to help you get started, here are a list of things any Unity developer should know about, and look up.

Utilise GPU Instancing

GPU instancing allows multiple objects with the same material to be rendered in a single draw call. This reduces the overhead associated with making separate draw calls for each object.

void Start()
{
Renderer renderer = GetComponent<Renderer>();
if (renderer != null)
{
renderer.material.enableInstancing = true;
}
}

Optimise Shaders

URP offers a Shader Graph that allows for visually designing shaders. Keep these tips in mind:

Simplify Shaders: Avoid complex operations in shaders, especially within fragment shaders.
Use LODs for Shaders: Employ Level of Detail techniques for shaders to reduce complexity for distant objects.

Texture Compression and Atlasing

Optimise textures to reduce memory usage and enhance rendering performance:

Use compressed texture formats like ASTC, BC7, or ETC2.
Combine multiple textures into atlases to reduce draw calls
- Generate or Collect Textures: Gather the individual textures you want to include in the atlas.
- Create Atlas Texture: Use a graphics editing tool (e.g., Photoshop) to create a new image file, which will serve as the atlas.
- Arrange Textures: Place the individual textures within the atlas, organizing them to minimize wasted space.
- Import into Unity: Import the atlas texture into your Unity project.
- Apply Atlas to Materials: Modify materials to use the atlas texture instead of individual textures.
- Adjust UV Mapping: Ensure that UV mapping for the objects corresponds correctly to the atlas.

Implement Occlusion Culling

Occlusion culling prevents the rendering of objects that are not visible to the camera. This reduces GPU workload.

Level of Detail (LOD)

LOD techniques involve using lower-polygon models or simplified textures for distant objects. URP provides tools for LOD implementation.

Prepare LOD Models

Create simplified versions of your object with fewer polygons for varying distances.

Add LOD Group

Select the object in the Hierarchy.
Add the LOD Group component.

Assign LOD Levels

In the LOD Group, add LOD levels and assign corresponding models.
Set Screen Relative Transition Height for each level.

Test and Adjust

Enter Play mode to observe LOD switching.
Fine-tune transition distances if needed.

Optimise LOD Models

Ensure LOD models are well-optimised for performance.

Verify Performance

Test on different devices to ensure desired performance improvements.

LOD is effective for objects like terrain, foliage, and complex structures. Apply it to objects with a significant impact on performance.

Particle System Optimisation

Efficiently managing particle systems is crucial for performance:

Limit the number of particles emitted at a time.
Use GPU simulation if suitable for your project.

Minimise Overdraw

Overdraw occurs when multiple transparent objects are rendered on top of each other. This can be mitigated with techniques such as:

Sorting objects by depth to minimise overdraw.
Utilizing techniques like depth pre-pass.

Optimise Post-Processing Effects

Post-processing effects can be resource-intensive. Consider:

Disabling or reducing the intensity of non-essential effects.
Using URP’s built-in optimisations for post-processing.

GPU-Driven Rendering

URP leverages GPU for various rendering tasks. Maximize its potential by utilizing Compute Shaders and other GPU-driven techniques.

Test on Target Hardware

Always test your game on the actual target hardware to ensure optimal performance. This allows you to uncover platform-specific issues and fine-tune accordingly.

Conclusion

Leveraging the Universal Render Pipeline in Unity provides a powerful set of tools for optimising game performance. By utilizing GPU instancing, optimising shaders, managing textures efficiently, and implementing various other techniques, you can create a high-performing game across a range of devices. Remember, continuous testing and iteration are crucial for achieving the best possible performance.

Feedback Culture: Constructive Criticism vs. Destructive Blame in Software Companies

Mon, 25 Sep 2023 08:10:43 +0100

In the fast-paced and dynamic world of software development, an effective feedback culture is paramount for growth, innovation, and overall success. However, not all feedback is created equal. It is crucial to distinguish between constructive criticism and destructive blame, as they can have vastly different impacts on teams and individuals within a software company.

The Importance of Constructive Criticism

Constructive criticism is a cornerstone of a healthy feedback culture within a software company. It is a process of providing thoughtful, specific, and actionable feedback aimed at helping individuals improve their skills, work, and contributions. Here’s why constructive criticism is essential:

Fosters Continuous Improvement

Constructive criticism is geared towards improvement. It pinpoints areas of strength and weakness, offering valuable insights for growth. In a software development context, this can lead to more efficient coding practices, improved problem-solving, and ultimately, better software products.

Encourages Open Communication

A culture of constructive criticism promotes open dialogue among team members. It creates an environment where everyone feels comfortable sharing ideas, seeking clarification, and offering feedback in return. This transparent communication is vital for innovation and problem-solving.

Builds Trust and Respect

When feedback is delivered in a constructive manner, it shows respect for the individual’s efforts and skills. It acknowledges their potential and fosters trust between team members and management. Trust is crucial for a collaborative and productive work environment.

Nurtures Professional Development

Constructive criticism is an investment in the professional growth of team members. It helps them identify areas where they can upskill and expand their knowledge. This not only benefits the individual but also contributes to the overall competence of the team.

The Pitfalls of Destructive Blame

Destructive blame, on the other hand, can be detrimental to the morale, productivity, and ultimately, the success of a software company. It involves assigning fault without offering any meaningful guidance or solutions. Here’s why it should be avoided:

Creates a Hostile Work Environment

Blame creates a toxic atmosphere where team members feel hesitant to take risks or share their ideas. It erodes trust and stifles creativity, hindering the potential for innovation and progress.

Hinders Problem-Solving

Blaming does not address the root cause of a problem. Instead, it places blame on individuals or teams, diverting attention from finding effective solutions. This can lead to persistent issues and a lack of progress.

Undermines Employee Morale

Constant blame erodes confidence and motivation. It can lead to disengagement, absenteeism, and, ultimately, a higher turnover rate. A demoralized team is less likely to be productive or deliver high-quality work.

Stifles Growth and Learning

Blame discourages individuals from taking risks or trying new approaches. Without the opportunity to learn from mistakes, growth and innovation are stifled, potentially leading to stagnation in a rapidly evolving field like software development.

Striking a Balance

To cultivate a healthy feedback culture, software companies must strike a balance between constructive criticism and destructive blame. This involves:

Clear Communication: Encourage open and honest communication channels within the team, where feedback is welcomed and valued.
Focus on Solutions: When issues arise, emphasize finding solutions rather than assigning blame. This promotes a problem-solving mindset.
Training and Development: Provide resources and opportunities for professional development, ensuring team members have the tools they need to excel.
Lead by Example: Managers and leaders should model effective feedback practices, setting the tone for the entire team.

In conclusion, a robust feedback culture is the cornerstone of success in software companies. Recognizing the distinction between constructive criticism and destructive blame is crucial for fostering an environment of growth, collaboration, and innovation. By prioritizing constructive feedback, software companies can unlock their full potential and thrive in an ever-evolving industry.

What is the difference betwen Promises and Observables in angular?

Sun, 24 Sep 2023 08:52:45 +0100

In Angular, Promises and Observables are both used for handling asynchronous operations, but they have some key differences in how they work and what they offer. Here are the main distinctions between the two:

Primises

Single Value: A Promise represents a single future value. It’s a proxy for a value not necessarily known when the promise is created.
Eager: Promises are eager, meaning that they immediately start executing when they are created.
Not Cancellable: Once a promise is created, it cannot be cancelled.
One-time: A Promise can only emit a single value, either a resolved value or a rejected reason.
.then() syntax: Promises are typically handled using .then() and .catch().

someAsyncFunction()
.then(result => {
// Do something with the result
 })
.catch(error => {
// Handle errors
 });

Observables

Multiple Values: An Observable is a stream of values that may be emitted over time. It can emit zero or more values.
Lazy: Observables are lazy, meaning they do not start emitting values until a subscription is made.
Cancellable: You can cancel an observable by unsubscribing.
Continuous: An Observable can keep emitting values over time, which makes it suitable for handling events or continuous streams of data.
.subscribe() syntax: Observables are typically handled using .subscribe().

someAsyncObservable()
.subscribe(
value => {
// Do something with each emitted value
 },
error => {
// Handle errors
 },
() => {
// Handle completion (optional)
 }
);

When to Use Which

Promises are suitable for operations that produce a single value. They are a good fit for scenarios where you make a single asynchronous request and expect a single response.
Observables are more powerful when dealing with multiple values or streams of data. They are especially useful for handling events, continuous data streams (like from WebSockets), and scenarios where you might need to cancel or transform the data before it reaches the subscriber.

In Angular, HTTP requests using the HttpClient return Observables by default, which allows you to leverage the full power of Observables for handling the asynchronous nature of HTTP requests.

In summary, if you’re dealing with a single asynchronous operation, a Promise might be sufficient. However, if you’re working with streams of data, events, or need more control over cancellation, Observables are the way to

Navigating Moral Dilemmas in Software Development

Sat, 23 Sep 2023 08:00:42 +0100

In today’s tech-driven world, being a software developer means more than just writing code. It means taking on the responsibility of ensuring that our creations not only work well but also do good. Let’s dive into some key ethical considerations for developers:

Respecting User Privacy

Think of user data like a trust fall - they’re putting their information in your hands. Be clear about what you’re collecting and why. Always ask for permission before diving into someone’s personal details.

Building Fortresses: Security First

Just like a well-locked door keeps your home safe, a secure software protects users. Don’t skimp on security measures. Regular updates and staying ahead of potential threats are your keys to success.

Bias Busting

Nobody likes playing favorites. Be vigilant against biases creeping into your algorithms. Ensure your software treats everyone fairly, regardless of who they are.

Inclusive Design

Imagine building a park with only one entrance - not very inviting, right? Make your software accessible to all, regardless of abilities. Think of it as creating a digital space that everyone can comfortably stroll through.

Transparent and Accountable

No one likes secrets, especially in tech. Be upfront about how your software works. And if something goes awry, take responsibility and make it right.

Navigating Ethical Dilemmas

In the whirlwind of development, ethics can sometimes take a back seat. Here’s how to keep it front and center:

Stay Informed

Keep an eye on the latest ethical discussions in tech. Knowing what’s up in the field helps you make better decisions.

Chat it Out

Have open conversations with your team about the ethics of your projects. Sometimes a fresh perspective is just what you need.

Follow Ethical Blueprints

Use established ethical guidelines like “privacy by design”. It’s like having a roadmap that leads you in the right direction.

Test for Ethics

Give your software a moral check-up. Test for biases, privacy, and anything else that might raise an ethical flag.

Keep Growing

Tech ethics is a bit like a growing plant. It needs care and attention. Stay curious and keep learning about new challenges and solutions.

In a Nutshell

Being a software developer isn’t just about writing code; it’s about making sure your creations make a positive impact. By weaving ethics into your work, you’re not just building better software - you’re building a better world.

Securing ASP.NET Core Applications Against SQL Injection Attacks with Microsoft SQL Server

Fri, 22 Sep 2023 21:23:32 +0100

SQL injection attacks remain a significant threat to web applications. When using Microsoft SQL Server with ASP.NET Core applications, it’s crucial to implement robust security measures to prevent SQL injection vulnerabilities. This article outlines best practices and techniques to avoid SQL injection attacks in ASP.NET Core applications.

Parameterized Queries and Stored Procedures

Parameterized Queries

Parameterized queries are a fundamental defense against SQL injection attacks. They allow you to separate SQL code from user input, making it extremely difficult for an attacker to inject malicious SQL code.

string query = "SELECT * FROM Users WHERE Username = @Username AND Password = @Password";
SqlCommand command = new SqlCommand(query, connection);
command.Parameters.AddWithValue("@Username", username);
command.Parameters.AddWithValue("@Password", password);

Stored Procedures

Stored procedures can further enhance security by encapsulating SQL logic on the server side. They prevent direct manipulation of the database by the user.

CREATE PROCEDURE dbo.ValidateUser
@Username NVARCHAR(50),
@Password NVARCHAR(50)
AS
BEGIN
SELECT * FROM Users WHERE Username = @Username AND Password = @Password
END

string procedureName = "ValidateUser";
SqlCommand command = new SqlCommand(procedureName, connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@Username", username);
command.Parameters.AddWithValue("@Password", password);

Use Object-Relational Mapping (ORM)

Using an ORM framework like Entity Framework Core can help mitigate SQL injection risks. ORM frameworks generate parameterized queries automatically, reducing the likelihood of introducing vulnerabilities through manual query construction.

Input Validation and Sanitization

Validate and sanitize user input thoroughly. Apply strict validation rules to ensure data adheres to expected formats and ranges. Utilize validation libraries and features provided by ASP.NET Core.

Principle of Least Privilege

When using Microsoft SQL Server with ASP.NET Core, it’s important to ensure that the SQL Server user account used by your application has the minimum required privileges. This principle limits the potential damage that can be caused if a SQL injection attack were to succeed.

For example, if your application only needs to perform SELECT operations on a specific table, create a user account with only those permissions:

CREATE LOGIN AppUser WITH PASSWORD = 'StrongPassword123';
CREATE USER AppUser FOR LOGIN AppUser;
GRANT SELECT ON YourTable TO AppUser;

Error Handling and Logging

Implementing detailed error handling and logging is essential for identifying and responding to potential attacks. Avoid exposing sensitive error messages to end-users, as they can provide valuable information to attackers.

try
{
// Code that interacts with the database
}
catch (Exception ex)
{
// Log the error
 logger.LogError(ex, "An error occurred while processing a database request.");
// Display a generic error message to the user
 ViewBag.ErrorMessage = "An error occurred while processing your request. Please try again later.";
}

Regular Security Audits and Penetration Testing

Regularly conducting security audits and penetration tests can help identify and address potential vulnerabilities, including SQL injection risks. There are various tools and services available for conducting security assessments.

For example, you can use tools like OWASP ZAP or hire a professional penetration testing service to evaluate your application’s security.

Additionally, consider implementing automated security scanning tools into your development and deployment process to catch potential vulnerabilities early in the development lifecycle.

By following these best practices and examples, you can significantly enhance the security of your ASP.NET Core application when using Microsoft SQL Server. Remember that security is an ongoing process, and staying vigilant against potential threats is crucial for safeguarding your application and its data.

Understanding the Gap between Sales and Software Development in Software Companies

Thu, 21 Sep 2023 09:09:31 +0100

In the intricate landscape of software companies, a notable divide often emerges between the sales and software development departments. Sales is hailed for its immediate revenue impact, while development is sometimes misconstrued as a cost center. This article aims to dissect the reasons behind this prevalent gap and shed light on the distinct roles that each department plays in a company’s success.

The gap between sales and software development departments in software companies is not necessarily due to “bad management” universally. While poor management can exacerbate the divide, the root causes of this gap are often more nuanced and can arise from a combination of factors. These may include:

The Sales Department: Catalysts of Revenue

Sales teams are celebrated for their pivotal role in revenue generation. Their tangible metrics, such as deals closed and customer acquisition, provide clear indicators of their performance. This direct impact on the company’s top line reinforces their status as revenue catalysts.

Software Development: Architects of the Future

On the contrary, software development is an investment in the company’s future. Their meticulous work underpins product quality and stability. The intricate processes of debugging and refining code, while less immediately visible, are essential for long-term success.

Roots of the Divide

The divide between sales and software development arises from the distinct nature of their contributions. Sales operates in the realm of immediate, measurable outcomes, while development focuses on long-term product refinement. This discrepancy in visibility and immediacy leads to the perceived gap.

Different Timelines, Same Goals

Sales and development operate on different timelines. Sales teams strive for swift results, while developers invest in enduring product excellence. Recognizing the complementary nature of these timelines is crucial in appreciating the value each department brings.

What Do We Do About It?

While management plays a crucial role in mitigating or exacerbating these factors, it’s important to recognize that the gap is often a complex interplay of various organizational dynamics. Effective management can certainly help bridge this gap by fostering a culture of collaboration, ensuring transparent communication, and recognizing the value of both departments. However, attributing the entire gap solely to “bad management” would oversimplify a multifaceted issue.

In software companies, the divide between sales and development departments stems from the inherent differences in their contributions. While one thrives on immediate, measurable outcomes, the other lays the foundation for long-term success. Understanding the distinctive roles of each department is essential in fostering a culture of mutual appreciation. By recognizing their shared goals and complementary timelines, companies can pave the way for a more harmonious and productive work environment, ultimately leading to sustained growth and success.

Working with Entity Framework Core in C#

Thu, 21 Sep 2023 09:00:46 +0100

Entity Framework Core (EF Core) is a powerful and lightweight Object-Relational Mapping (ORM) framework for .NET applications. It simplifies database operations by allowing developers to work with .NET objects rather than writing raw SQL queries. In this tutorial, we’ll explore the fundamentals of using Entity Framework Core in C#.

Getting Started

Installing Entity Framework Core

Before you can start using EF Core, you need to install the necessary packages. In your project, open the NuGet Package Manager and install the Microsoft.EntityFrameworkCore and Microsoft.EntityFrameworkCore.SqlServer packages.

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer

Creating a DbContext

The DbContext is the heart of EF Core. It represents a session with the database and allows you to perform operations like querying, inserting, updating, and deleting entities.

public class AppDbContext : DbContext
{
public DbSet<User> Users { get; set; }
// Add other DbSet properties for your entities here

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer("YourConnectionString");
}
}

Replace User with your own entity and provide your database connection string.

Defining Entities

Entities are C# classes that represent tables in your database. Each property in the class corresponds to a column in the table.

public class User
{
public int Id { get; set; }
public string Name { get; set; }
public string Email { get; set; }
}

Performing CRUD Operations

Creating Records

using (var context = new AppDbContext())
{
var newUser = new User { Name = "John Doe", Email = "john@example.com" };
context.Users.Add(newUser);
context.SaveChanges();
}

Reading Records

using (var context = new AppDbContext())
{
var users = context.Users.ToList();
foreach (var user in users)
{
Console.WriteLine($"{user.Id}: {user.Name} - {user.Email}");
}
}

Updating Records

using (var context = new AppDbContext())
{
var user = context.Users.FirstOrDefault(u => u.Id == 1);
if (user != null)
{
user.Email = "john.doe@newdomain.com";
context.SaveChanges();
}
}

Deleting Records

using (var context = new AppDbContext())
{
var user = context.Users.FirstOrDefault(u => u.Id == 1);
if (user != null)
{
context.Users.Remove(user);
context.SaveChanges();
}
}

Querying with LINQ

EF Core allows you to use LINQ (Language Integrated Query) to write expressive and powerful queries.

using (var context = new AppDbContext())
{
var users = context.Users
.Where(u => u.Name.Contains("John"))
.OrderBy(u => u.Name)
.ToList();
}

Conclusion

Entity Framework Core provides a seamless way to interact with databases in C# applications. With its powerful features and simplicity, it has become a popular choice for .NET developers. By following this tutorial, you’ve gained a solid foundation for working with EF Core, enabling you to build robust and efficient data-driven applications.

Building Marlin 2.0.x Firmware for Ender 3 3D Printer and Ender 3 Clones

Wed, 20 Sep 2023 15:58:05 +0000

The Marlin firmware is an open-source firmware widely used in 3D printers, known for its flexibility and extensive feature set. This tutorial will guide you through the process of building the Marlin firmware for the Creality Ender 3 using PlatformIO, a powerful open-source ecosystem for IoT development, and Visual Studio Code (VSCode), a popular code editor.

Prerequisites

Before we begin, make sure you have the following:

Visual Studio Code (VSCode)

Download and install Visual Studio Code.

PlatformIO Extension

Open VSCode, go to the Extensions view (Ctrl+Shift+X or Cmd+Shift+X on Mac), and search for “PlatformIO IDE”. Install it.

Clone Marlin Firmware Repository

Open a terminal or command prompt and navigate to the directory where you want to store the Marlin firmware. Run the command:

git clone https://github.com/MarlinFirmware/Marlin.git

Building Marlin Firmware for Ender 3

Open Project in VSCode
- Open VSCode, and go to File > Open Folder..., then select the Marlin folder you just cloned.
Select Board Configuration
- In the VSCode sidebar, expand the Marlin folder and navigate to Marlin/Configuration.h. This file contains the configuration settings for your printer. Look for the section that mentions ENDER_3 or similar. Make sure it’s uncommented (remove // at the beginning of the line) and save the file.
Select Printer Options
- In the same Configuration.h file, scroll down to customize other settings like bed size, stepper driver type, and more according to your specific Ender 3 model and any modifications you’ve made.
Select Environment in PlatformIO
- Click on the PlatformIO icon on the sidebar (looks like a little alien head). Under “Project Tasks”, expand the env: dropdown and select STM32F103RET6_creality for Ender 3.
Build the Firmware
- Click on the “PlatformIO: Build” icon in the PlatformIO sidebar.
Upload the Firmware
- If you have a bootloader installed on your Ender 3, you can use a USB cable to upload the firmware. Otherwise, you’ll need to use an ISP programmer.

Flashing Firmware (Optional)

Bootloader Method (Recommended)
- If you have a bootloader, you can use a USB cable to flash the firmware:
- Connect your printer to your computer via USB.
- Click on “PlatformIO: Upload” in the PlatformIO sidebar.
ISP Programmer Method (If No Bootloader)
- You’ll need an ISP programmer like an AVRISP mkII.
- Connect the ISP programmer to your printer’s board.
- In PlatformIO, click on “PlatformIO: Upload using Programmer” in the sidebar

Notes

Backup Configuration: Before you make any changes, always back up your original Configuration.h and Configuration_adv.h files.
Test the Firmware: After flashing, test the printer to ensure it functions correctly.

Remember, modifying firmware can potentially damage your printer if done incorrectly. Proceed with caution and double-check your configurations. If you encounter issues, refer to the Marlin Documentation and community forums for help.

When Does Automating Away a Coworkers Job Cross The Line into Bullying

Wed, 20 Sep 2023 08:00:10 +0100

In a previous job, I found that a coworker was spending a full work week building an excel spreadsheet from our Azure DevOps data, so I spent about an hour writing a small program to replace his entire job. This triggered an arms race between myself and the coworker where they would slightly change what they added to the excel spreadsheet, and I would add that into the simple program (and then make it better). This went on for about 2 weeks until I was called into the manager’s office and was told that I was bullying the coworker by doing this, which I disagreed with.

This lead me to thinking about, when does automating away a coworkers job cross the line into bullying. Automating a manual process in the workplace is not inherently bullying. However, if the automation is implemented without proper consideration for the impact on employees, it can potentially be perceived as bullying or create a hostile work environment. There are both positive and negative aspects (which include aspects that could be considered bullying), they are as follows:

Positive Aspects of Automating a Manual Process in the Workplace:

Increased Efficiency and Productivity: Automation can significantly enhance the speed and accuracy of tasks, leading to higher overall productivity.
Cost Savings: By reducing the need for manual labor, companies can save on labor costs and potentially allocate resources to other areas of the business.
Quality Improvement: Automated processes often result in fewer errors and a higher level of consistency in output.
Time Allocation for Strategic Tasks: Employees can shift their focus from routine, manual tasks to more strategic, creative, or value-added activities that require human judgment and decision-making.
Competitive Advantage: Companies that leverage automation effectively can gain a competitive edge in their industry by being more agile and responsive to market demands.

Negative Aspects of Automating a Manual Process in the Workplace (Potentially Involving Bullying):

Job Displacement: Automation can lead to job loss for employees whose roles are automated, potentially causing financial stress and job insecurity. In some cases, if not handled with sensitivity and respect, the process of job displacement can be perceived as bullying.
Reskilling Challenges: Employees may face difficulties in transitioning to new roles or acquiring the necessary skills to work alongside automated systems. Inadequate support or a lack of resources for upskilling can contribute to feelings of isolation and frustration, resembling a form of workplace bullying.
Emotional Impact: Sudden or poorly managed automation can lead to feelings of exclusion, resentment, or fear among employees. If not addressed empathetically, these emotions can contribute to a hostile work environment.
Potential for Errors in Automation: Depending on the complexity of the process and the quality of the automation, there may be instances where errors occur, potentially causing disruptions. Blaming employees for errors caused by automation, rather than addressing the root cause, can be considered a form of bullying.
Over-Reliance on Technology: An excessive reliance on automated systems can leave a company vulnerable in situations where technology fails or requires maintenance. Pressuring employees to perform at an unsustainable pace due to overreliance on automation can be a form of bullying.
Cultural Resistance: Some employees may resist automation due to concerns about job security or a preference for traditional work methods. Disregarding their concerns and forcing the adoption of automation without addressing these fears can create a hostile work environment, resembling a form of bullying.

It’s crucial for organizations to consider the potential negative impacts of automation and proactively address them with empathy and sensitivity to prevent any situation from resembling bullying in the workplace.

Update: Knowing what I know now (years later, and multiple companies later), I would have gone about this differently. Rather than just writing the application, I would have written a detailed case to my management. I would have detailed the amount of time taken to compile the spreadsheet by a staff member and the costs associated with that, and then detailed the amount of time and cost it would have taken to build the application and the ongoing maintenance costs. Companies talk money, and only money, not only would I not have been accused of bullying in this case, I would have been praised for saving a large source of inefficiency, and paid for writing the application.

Time Series Anomaly Detection with ML.NET in C#

Tue, 19 Sep 2023 13:47:33 +0000

ML.NET provides a very simple way of performing Anomaly Detection on random variables as long as they are independent and identically distributed (i.e. daily sales totals recorded at the end of each and every day). With it also being possible to detect anomalies without requiring past examples beyond your dataset.

Prerequisites

Before we get started, make sure you have the following prerequisites:

Visual Studio with .NET Core or .NET Framework installed.
Basic understanding of C# programming language.

Step 1: Set Up Your Project

Open Visual Studio and create a new C# console application.

Step 2: Install ML.NET Package

Right-click on your project in Solution Explorer.
Select “Manage NuGet Packages…”
Search for “Microsoft.ML” and install the latest version.

Step 3: Import Necessary Libraries

using Microsoft.ML;
using Microsoft.ML.Data;

Step 4: Define Your Data Classes

In this example, we’ll assume you have a class called TimeSeriesData with two properties: TimeStamp and Value.

public class TimeSeriesData
{
 [LoadColumn(0)]
public DateTime TimeStamp;

 [LoadColumn(1)]
public float Value;
}

Step 5: Load and Prepare Your Data

Load your time series data into a DataView and split it into training and testing sets.

var context = new MLContext();
var data = context.Data.LoadFromTextFile<TimeSeriesData>("path/to/your/data.csv", separatorChar: ',');
var dataSplit = context.Data.TrainTestSplit(data);

Step 6: Define Your Model

Choose an anomaly detection algorithm. In this example, we’ll use the SrCnnEntireAnomalyDetector algorithm.

var pipeline = context.Transforms.DetectAnomalyBySrCnn("Value", nameof(TimeSeriesPrediction.Prediction), 10)
.Append(context.Transforms.CopyColumns("Prediction", nameof(TimeSeriesPrediction.Prediction)));

Step 7: Train Your Model

var model = pipeline.Fit(dataSplit.TrainSet);

Step 8: Make Predictions

var predictions = model.Transform(dataSplit.TestSet);
var anomalies = context.Data.FilterRowsByBoolColumn(predictions, "Prediction");

Step 9: Evaluate the Model

var metrics = context.AnomalyDetection.Evaluate(dataSplit.TestSet, "Prediction");
Console.WriteLine($"AUC: {metrics.AreaUnderRocCurve}");

Step 10: Interpret the Results

You can now use the anomalies DataView to analyze and interpret the detected anomalies in your time series data.

Step 11: Deploy and Use Your Model

To use the model in your application, you can save it and load it as needed:

context.Model.Save(model, dataSplit.TrainSet.Schema, "model.zip");
var loadedModel = context.Model.Load("model.zip", out var modelSchema);

Congratulations! You’ve successfully implemented time series anomaly detection using ML.NET in C#. This tutorial provides a basic example, but you can further refine and expand your model based on your specific use case and data.

Remember to replace the placeholders in the code (like “path/to/your/data.csv”) with your actual file paths and feel free to experiment with different algorithms, hyperparameters, and techniques to improve the accuracy of your anomaly detection model.

Company Culture: "No Blame" vs "Know Blame"

Tue, 19 Sep 2023 09:00:00 +0100

Companies often claim that the operate a “no blame culture”, and then joke tht its actually a “know blame culture”. A “no blame” culture and a “know blame” culture may sound similar, but they have significant differences in their underlying principles and how they are practiced within a software development organization. This is particularly notable in the software development industry due to its unique characteristics.

Intent and Focus

No Blame Culture: In a true “no blame” culture within a software development company, the focus is on identifying and fixing system-level issues that contribute to bugs, glitches, or project setbacks. The emphasis is on learning and refining processes, rather than assigning blame to individual developers.
Know Blame Culture: In a “know blame” culture, the main goal is to pinpoint specific developers responsible for errors or delays. The focus is on holding individuals accountable, often with the intention of reprimanding or punishing them.

The prevalence of a “know blame” culture in software companies can be attributed to several industry-specific factors. In software development, output is often easily quantifiable, which makes it more straightforward to assign individual responsibility for bugs, defects, or project delays. The complex and interdependent nature of code can also lead to a tendency to focus on individual blame when issues arise.

Response to Failure

No Blame Culture: When a coding error or project setback occurs, the emphasis is on understanding the underlying causes and finding solutions. The focus is on preventing similar incidents in the future.
Know Blame Culture: In a “know blame” culture, the immediate response to a mistake may be to identify the responsible developer and take disciplinary action.

Psychological Safety

No Blame Culture: A “no blame” culture fosters an environment of psychological safety, where developers feel comfortable admitting mistakes, asking for help, or reporting problems without fear of reprisal.
Know Blame Culture: A “know blame” culture can create a tense atmosphere where developers may be hesitant to admit their mistakes or report issues due to the fear of punishment.

The competitive nature of the software industry can further exacerbate this, creating a results-driven culture where the focus is on delivering high-quality products quickly, potentially overshadowing the importance of a blame-free environment.

Leadership Behavior

No Blame Culture: Leaders in a “no blame” culture encourage open communication, focus on collaborative problem-solving, and support developers in learning from mistakes.
Know Blame Culture: Leaders in a “know blame” culture may engage in finger-pointing, publicly reprimand developers, or create an atmosphere of fear and blame.

Learning and Improvement

No Blame Culture: Continuous improvement and learning are fundamental values. The company invests in training, feedback mechanisms, and process enhancements to prevent future errors.
Know Blame Culture: While individuals may be held accountable for their mistakes, there may be little emphasis on systemic improvements or learning from the experiences.

Changing ingrained cultural norms, especially in older or more established software companies, can be a slow process. However, many progressive companies within the industry are actively working to shift towards a more constructive “no blame” culture that prioritizes learning, collaboration, and systemic improvement over assigning individual blame.

Feedback Mechanisms

No Blame Culture: Feedback is constructive, focused on improving code quality, processes, and project outcomes. It aims to help developers and the organization grow and learn from experiences.
Know Blame Culture: Feedback may be punitive, aimed at reprimanding or punishing developers for their mistakes.

In assessing the actual culture of a software development company, it’s crucial to look beyond stated values and observe how issues are handled in practice, how leaders respond, and whether there is a genuine commitment to continuous improvement in the development process. Remember, while the prevalence of a “know blame” culture in some software companies is influenced by industry-specific factors, many forward-thinking organizations are actively working to shift towards a more constructive and growth-oriented approach.

How a Zero Trust Policy Hampers Software Developer Productivity

Mon, 18 Sep 2023 08:19:18 +0100

In recent years, the Zero Trust security model has gained prominence as a robust approach to safeguarding digital assets. However, when applied within a software development company, this policy can inadvertently hinder the productivity of software developers. This article delves into the specific challenges that arise when implementing a Zero Trust policy in this context, shedding light on why it may not be the most conducive approach.

Restricting Development Environment Flexibility

Software development thrives on flexibility. Developers often need the freedom to swiftly set up new environments, integrate various tools, and experiment with different configurations. A Zero Trust policy, characterized by stringent access controls and micro-segmentation, can impede this agile development process. It may lead to delays and frustrations for developers who require timely access to resources.

Collaboration is the lifeblood of software development. Developers frequently engage in code sharing, joint debugging sessions, and collaborative code reviews. The implementation of a Zero Trust policy introduces barriers to this essential teamwork. For example, the rigorous access controls may hinder the seamless sharing of resources, leading to a more disjointed and less productive development process.

Navigating Authentication Overload

Modern software development often involves integrating with a multitude of third-party services, APIs, and libraries. A Zero Trust policy can complicate this process by necessitating extensive authentication and authorization procedures for every external service. This added layer of security may impede the timely integration of crucial components, potentially delaying project milestones.

Balancing Security and Developer Efficiency

While security is paramount, there’s a delicate balance to be struck between security measures and productivity. A Zero Trust policy, if not thoughtfully implemented, can tilt the scales too far towards security, potentially sacrificing the speed and efficiency of the development process.

Managing Complexity in Security Configuration

Implementing a Zero Trust policy demands a substantial investment in time and resources. It involves configuring and overseeing an array of security tools, policies, and protocols. In a software development company, where the primary focus should be on creating innovative solutions, this added complexity can divert resources away from the core mission.

Developer Morale and User Experience

Excessive security measures can erode the user experience for developers. Constantly navigating authentication barriers can lead to frustration, which in turn can impact job satisfaction. Over time, this could even contribute to higher turnover rates within the development team.

Potential Over-Reliance on Technology

A Zero Trust policy often relies heavily on advanced technology solutions, including identity and access management tools, network monitoring systems, and more. Relying too heavily on technology can create a false sense of security. It’s crucial to remember that no system is infallible, and human factors should not be overlooked.

Balancing Security with Developer Productivity

While a Zero Trust policy has its merits, applying it within a software development company requires careful consideration of the specific needs and workflows of developers. Striking a balance between security and productivity is essential for fostering an environment where developers can innovate efficiently and effectively, without unnecessary constraints.

The Pitfalls of Overmanaging Software Developers

Fri, 15 Sep 2023 11:03:54 +0100

In the fast-paced world of software development, achieving high levels of productivity is paramount for successful project completion. However, counterintuitively, overmanaging software developers can often lead to reduced efficiency and hinder the overall progress of a project. This article explores the reasons behind this phenomenon and suggests alternative approaches to foster a more productive work environment.

Micromanagement stifles creativity

One of the primary drawbacks of overmanagement is the stifling of creativity. Software development is a field that demands a degree of creative problem-solving. When developers are constantly and overly micromanaged, they are less likely to think outside the box and create innovative solutions. This leads to a decrease in the quality and originality of the code produced.

Loss of autonomy and ownership

Excessive oversight can strip developers of their sense of ownership over their work. Autonomy is a powerful motivator in the software development industry. When developers have the freedom and discretion to make decisions about how to approach a task or solve a problem, they feel more invested in the outcome. Overmanagement can erode this sense of ownership, leading to a decrease in commitment and motivation.

Reduction in problem-solving skills

Problem-solving is a critical skill for software developers. When managers solve every problem for their team, developers are deprived of the opportunity to learn and grow. It’s essential to allow developers to grapple with challenges on their own, as this fosters independence and helps them develop crucial problem-solving skills.

Demotivation and burnout

Overmanagement can lead to demotivation and, ultimately, burnout among developers. Constant scrutiny and a lack of trust can create a stressful work environment. When developers feel that their every move is being watched, it can lead to anxiety and a decreased sense of job satisfaction. This, in turn, can result in higher turnover rates and a loss of valuable talent.

Reduced adaptability and responsiveness

In today’s dynamic tech landscape, adaptability is key. Overmanaging can impede a team’s ability to respond quickly to changing requirements or emerging technologies. When developers are not empowered to make decisions and adjustments on their own, the development process becomes slow and inflexible.

Inefficiencies in communication

Excessive management can lead to bottlenecks in communication. Instead of direct communication between team members, information has to flow through multiple layers of management. This can result in delays and misinterpretations, further impeding progress.

Finding the Right Balance

Instead of micromanaging, it’s important to establish a culture of trust, autonomy, and open communication. Here are some strategies to strike the right balance:

Set clear expectations: Provide a clear roadmap and define project objectives. This gives developers a sense of direction without stifling creativity.
Encourage autonomy: Allow developers to take ownership of their work. Provide guidance and support but let them make decisions about how to approach tasks.
Foster a culture of learning: Encourage developers to seek out solutions independently. Provide opportunities for professional growth and skill development.
Maintain open communication channels: Foster an environment where developers feel comfortable sharing their ideas, concerns, and challenges.
Trust your team: Trust is the cornerstone of a productive team. When developers feel trusted, they are more likely to take initiative and demonstrate a high level of accountability.

In conclusion, while managers need to provide guidance and support, overmanaging software developers can lead to reduced productivity, creativity, and morale. Striking a balance between oversight and autonomy is crucial for fostering a productive and innovative development team.

Linus Tech Tips, Gamers Nexus, Ethics and Responsibility

Tue, 15 Aug 2023 14:04:59 +0100

Yesterday, Gamers Nexus posted a video titled “The Problem with Linus Tech Tips: Accuracy, Ethics, & Responsibility”, which addressed several concerns that GN have with Linus Tech Tips, the LMG Labs, and Linus Himself.

This then sparked a long thread on the LTT forums where Linus himself responded to the video and several of the comments made by the forum users around the video.

With this post, I would mostly like to address several things Linus stated in his response to the video.

There won’t be a big WAN Show segment about this or anything. Most of what I have to say, I’ve already said, and I’ve done so privately.

This is a public issue, the general public have now seen what Steve and GN have to say, and attempting to keep the responses to Steve private, suggest that there are things that Linus does not want to be in the public, suggesting intentional wrong doing, rather than simply making mistakes.

To Steve, I expressed my disappointment that he didn’t go through proper journalistic practices in creating this piece. He has my email and number (along with numerous other members of our team) and could have asked me for context that may have proven to be valuable (like the fact that we didn’t ‘sell’ the monoblock, but rather auctioned it for charity due to a miscommunication.

Firstly, to continue what i said on the previous quote, why are there things Linus wants to keep private here on an issue that is already in the public eye? Secondly, contacting Linus personally, and resolving it quietly. is the exact opposite of “proper journalistic practices”. Journalists can ask the subject of a story for comment, but it is not at all required, especially if the request for comment will affect the story or affect the journalist writing the story. On the point of “selling” the monoblock, legally, they accepted cash for that waterblock, and then donated the cash straight to charity, that is a sale in Canada, the USA, the UK and almost anywhere else in the world.

To my team (and my CEO’s team, but realistically I was at the helm for all of these errors, so I need to own it), I stressed the importance of diligence in our work because there are so many eyes on us. We are going through some growing pains - we’ve been very public about them in the interest of transparency - and it’s clear we have some work to do on internal processes and communication. We have already been doing a lot of work internally to clean up our processes, but these things take time. Rome wasn’t built in a day, but that’s no excuse for sloppiness

Linus appears here to be suggesting that the LMG Lab is a “work in progress”, yet they are presenting the numbers without any disclaimer stating that they could be incorrect, they are stating the numbers as absolute fact. The Lab cannot both be a “work in progress” and absolute fact at the same time, if Linus and the new CEO want to “take ownership” of this, any data coming from the labs in previous videos and all future videos (until these issues have been ironed out) should come with a visible, and audible disclaimer stating that the labs is a work in progress.

Linus has also stated on the WAN Show that he is unwilling to spend “100, 200, 500 dollars” on fixing these mistakes, before they are published, on videos that make them 100s of 1000s of dollars. Why would such a trivial amount of money not be worth spending on factual accuracy? What money has been skimped on elsewhere on factual inaccuracies that have not been picked up on? Linus’s stance on this opens up more questions than it answers.

Now, for my community, all I can say is the same things I always say. We know that we’re not perfect. We wear our imperfection on our sleeves in the interest of ensuring that we stay accountable to you. But it’s sad and unfortunate when this transparency gets warped into a bad thing. The Labs team is hard at work hard creating processes and tools to generate data that will benefit all consumers - a work in progress that is very much not done and that we’ve communicated needs to be treated as such.

There is no transparency, it took somebody else to point out all of LMGs mistakes to prompt a post from Linus. The “corrections” they have made, are made in the laziest and cheapest and least visible way possible. Are LMG looking to strive for accuracy, or a better bottom line?

With all of that said, I still disagree that the Billet Labs video (not the situation with the return, which I’ve already addressed above) is an ‘accuracy’ issue. It’s more like I just read the room wrong. We COULD have re-tested it with perfect accuracy, but to do so PROPERLY - accounting for which cases it could be installed in (none) and which radiators it would be plumbed with (again… mystery) would have been impossible… and also didn’t affect the conclusion of the video… OR SO I THOUGHT…

If LMG/Linus now know that the video is entirely factually inaccurate, why does the video still remain public? Why has there not been any insert into the video to let consumers know that the entire content of the video is incorrect? Why has LMG not added inserts into the video to show what they did wrong? Again, this is down to the bottom line of the company being a bigger priority than factual accuracy.

Adam and I were talking about this today. He advocated for re-testing it regardless of how non-viable it was as a product at the time and I think he expressed really well today why it mattered. It was like making a video about a supercar. It doesn’t mater if no one watching will buy it. They just wanna see it rip. I missed that, but it wasn’t because I didn’t care about the consumer.. it was because I was so focused on how this product impacted a potential buyer. Either way, clearly my bad, but my intention was never to harm Billet Labs

Here Linus states that other members of the team, specifically the writer and co-presenter of the video, were not pleased with the video and its findings and wated to retest, and Linus vetoed that and let the video go out as it was, and still allows it to remain live to this day (at the time of writing this post). If the intention is not to harm billet labs, then why offer such harsh opinions on known bad data, and why leave the known bad video, up and live?

Either way, I’m sorry I got the community’s priorities mixed-up on this one, and that we didn’t show the Billet in the best light. Our intention wasn’t to hurt anyone. We wanted no one to buy it (because it’s an egregious waste of money no matter what temps it runs at) and we wanted Billet to make something marketable (so they can, y’know, eat).

Linus is only sorry now that he has been called out, hes stated several times on the WAN show that he doesnt want to pay trivial amounts of money to fix factual inaccuracies in videos, hes left several known factually inaccurate videos live. Linus and LMG need to take real action on this rather than making a placebo statement to try and quell the rage from the community.

Conclusion

In conclusion, I dont dislike Linus, I dont dislike LMG/LTT, and I dont dislike what LMG are trying to do with the Labs, but I do think they need to drastically clean up their act in order to stop themselves from becoming an industry joke and having the labs be dead before they even get into the full swing. They are the largest tech youtube channel where a lot of people get their information from, they influence a lot of people and what those people buy, and can influence whether or not a small company lives or dies. With that power, they need to be incredibly careful, or they will continue to be called out and will suffer unfixable reputational damage.

Hopefully LMG fix their issues internally, and a proper response is made, and the previously known factually inaccurate videos are fixed, and future videos are fixed correctly with visible and audible corrections.

5 Reasons C# Is Better Than Java

Tue, 15 Aug 2023 13:59:17 +0100

When it comes to choosing the right programming language, developers often find themselves faced with a myriad of options. Among these, C# and Java are two prominent contenders, each with its own strengths and weaknesses. In this article, we’ll delve into five compelling reasons why C# outshines Java, making it an exceptional choice for modern software development.

Here are 5 reasons why choosing C# is a better idea than choosing Java.

Elegant Syntax and Modern Features:

C# boasts an elegant and concise syntax that enhances code readability and reduces the potential for errors. Its modern features, such as properties, events, and LINQ (Language Integrated Query), contribute to more efficient and expressive code. On the other hand, Java’s syntax can be more verbose and less intuitive, often requiring extra lines of code to accomplish similar tasks.

Seamless Integration with Microsoft Ecosystem:

C# is a language closely associated with the Microsoft ecosystem, offering seamless integration with various Microsoft technologies, such as .NET, Azure, and Visual Studio. Developers working on Windows applications, web services, or cloud solutions can leverage these integrations to streamline their development process. While Java is cross-platform, C#’s integration with Microsoft tools and services provides a more cohesive environment for Windows-centric projects.

Powerful Development Environment:

Visual Studio, the primary integrated development environment (IDE) for C#, is renowned for its robust set of tools, debugging capabilities, and performance profiling features. It provides developers with an efficient workflow and a rich ecosystem of extensions. While Java has IDEs like IntelliJ IDEA and Eclipse, Visual Studio’s comprehensive toolset gives C# an edge in terms of productivity and code quality.

Language Innovations and Regular Updates:

C# has been consistently evolving, introducing new language features and enhancements to keep up with modern programming paradigms. With the introduction of C# 9 and beyond, features like record types, pattern matching, and improved nullable reference types have made C# even more powerful and expressive. Java, while also evolving, might have a more gradual adoption rate for new language features due to its larger and more diverse community.

Unified Development Stack:

C# offers a unified development stack through the .NET framework, allowing developers to build a wide range of applications, including desktop, web, mobile, and cloud-based solutions. This unified approach simplifies the development process by providing a consistent set of libraries, tools, and APIs. In contrast, Java developers might need to work with different frameworks and libraries for various application types, potentially leading to a steeper learning curve and increased complexity.

In Summary…

While both C# and Java have their merits, C# stands out as a language that combines elegant syntax, powerful tooling, seamless integration with the Microsoft ecosystem, and regular updates to enhance its capabilities. These factors make C# a compelling choice for developers looking to build robust and efficient software solutions in a modern development landscape. As technology continues to evolve, C# remains at the forefront, offering a vibrant and dynamic environment for innovation and creation.

Yes You Can Block Elon Musk on Twitter

Fri, 28 Jul 2023 21:21:46 +0100

After being told by somebody on discord that it “is impossible to block elon musk on twitter”, when in fact, it is quite simple. I decided to make this post and this video to show just how simple it is.

It is actually quite simple when you know how:

Search for “elon musk”
Click “…” button
Click “block”
DONE!

Or watch the youtube video below:

How to Become a Better Software Developer With These GitHub Repos

Wed, 26 Jul 2023 10:23:44 +0100

GitHub hosts millions of different repositories, most are projects that developers are working on, but a fraction of them are valuable resources for learning. Over time, I have collected a list of repos that contain these valuable resources.

Every Programmer Should Know

No matter how much you know, you never know enough.

“Every Programmer Should Know” is a collection of mostly technical things that all software developers should know. With this repository, you might learn a few new tricks, and this alone justifies spending some time on this collection.

Build your own X

Have you ever tried to create your own operating system? Or your own BitTorrent client?

Build your own X tries to close the knowledge gap in implementing some basic but also some pretty advanced topics. This whole repository shows you that anybody can create anything if they are willing.

Awesome Guidelines

Awesome Guidelines is a little different. Instead of distilling knowledge into a collection or a book itself, it gives you some of the most basic foundations a programmer regularly needs: Coding and formatting guidelines.

Code is read way more often than it is actually written. This alone justifies formatting your code in some way or the other – at least to the extent that you and everyone you work with can agree on how your code should look.

Professional Programming

Professional Programming is a classic resource collection with many tips on outstanding books, many more worthwhile articles to consume, and a link for nearly everything you can probably imagine.

Project Based Learning

Practice is the best way to learn software development. Repeatedly solving specific problems fortifies your knowledge and gives your brain the reason to memorize all those concepts you apply during your work.

Project Based Learning is a list of programming tutorials that shows aspiring software developers how to build an application from scratch. It contains projects in many different languages.

The System Design Primer

System design is one of those fields where practice especially makes you better. Theory often lacks behind real-world use cases and issues you encounter in the wild.

This repository, however, is an incredible example of how to teach the very practical domain of system design with Python. If you manage to finish going through this repository, you’ll be a pretty dangerous software engineer who knows their way around system design way better than many of their peers.

Coding Interview University

Becoming a software developer at a large company can be a challenging task.

Tech interviews can be daunting and are often nothing like the actual job. Some even go so far as to say that you need a whole different set of skills to pass a tech interview than you need to do the job.

Coding Interview University is a repository that aims at precisely guiding you through the process of becoming competent in tech interview situations, all while additionally teaching you many crucial computer science fundamentals.

30 seconds of code

30 seconds of code contains JavaScript code snippets.

This repository is the perfect bookmark if you ever get stuck. Just jump into it and look at whether there is already a solution for your problem.

New and Interesting Features in C# 12

Thu, 13 Jul 2023 00:08:00 +0100

C# 12 introduces several features aimed at laying the foundation for future performance enhancements. These features include easy access to inline arrays, an experimental feature called interceptors, and enhancements to the nameof keyword.

Inline arrays allow libraries to use them more conveniently without additional effort. They provide efficient and type-safe access to a contiguous sequence of primitives. The compiler generates different IL (Intermediate Language) code to access inline arrays, resulting in performance gains without requiring changes to your code.

Interceptors are an experimental feature intended for advanced scenarios, particularly for better ahead-of-time compilation (AOT). They allow specific method calls to be rerouted to different code. Interceptors are primarily used in conjunction with source generators. By enabling interceptors in your project file, you can benefit from code patterns such as optimized static code generation, direct call bypassing allocation and indirection, vectorization, dependency graph resolution, query translation, and compile-time serialization.

It’s important to note that interceptors are experimental and should not be used in production. They may undergo changes or be removed in future versions of C# and .NET.

To access C# 12 features, you need to install the latest Visual Studio preview or the latest .NET SDK. Additionally, you’ll need to set the language version of your project to “preview” in the project file. Interceptors require an additional flag in the project file to enable them.

Read more over on the microsoft dev blogs.

Creating Windows and Linux background services in dotnet 6.0/7.0

Sun, 02 Jul 2023 22:00:00 +0100

There are times when you need an application to just sit there in the background and deal with the same repetitive task over and over again.

In dotnet core 3.0, a new type of template was introduced, “Worker Service”, which is a very easy way of creating Windows Services and Linux Daemons, and it is just as easy in dotnet 6 and 7 (if not, even easier).

The Basics

The “worker” template can be accessed in one of two ways:

via the command line

mkdir myNewWorker
cd myNewWorker
dotnet new worker

via Visual Studio

Either way, you end up with the same basic template to start with, which is your Startup class, and your Worker class.

The Startup Class

The startup class is your entry point to the executable In the initial template, we are

public static IHostBuilder CreateHostBuilder(string[] args)
{
return Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService<Worker>();
});
}

The first thing we need to do is add the generic host library nuget package Microsoft.Extensions.Hosting and switch the SDK to the worker SDK.

You can do this by opening up your csproj file and making the following changes:

<Project Sdk="Microsoft.NET.Sdk.Worker">
<PropertyGroup>
<TargetFramework>net7.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Hosting" />
</ItemGroup>
</Project>

Next, we need to add the following lines to our CreateHostBuilder.

public static IHostBuilder CreateHostBuilder(string[] args)
{
return Host.CreateDefaultBuilder(args)
.UseSystemd()
.UseWindowsService()
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService<Worker>();
});
}

The Worker class

Lastly, we can create our background service worker class, which is executed asynchronously, has logging, and has configuration built in too.

 public class Worker : BackgroundService
{
private readonly ILogger<Worker> _logger;
private readonly IConfiguration configuration;
public Worker(ILogger<Worker> logger, IConfiguration configuration)
{
_logger = logger;
this.configuration = configuration;
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
await Task.Delay(1000, stoppingToken);
}
}
}

C# Basics: Generate Random Numbers

Sat, 01 Jul 2023 11:27:32 +0100

Random numbers play a crucial role in various applications, from gaming to cryptography. In C#, generating random numbers is made easy with the help of the built-in Random class. In this article, we will explore different methods of generating random numbers in C# and discuss their applications.

Method 1: Using the Random Class

The most common way to generate random numbers in C# is by utilizing the Random class from the System namespace. The Random class provides a convenient interface to generate random numbers based on a seed value. Here’s an example:

Random random = new Random(); // Create an instance of the Random class

int randomNumber = random.Next(); // Generate a random integer
double randomDouble = random.NextDouble(); // Generate a random double between 0.0 and 1.0

The Next() method generates a non-negative random integer, while NextDouble() generates a random double value between 0.0 and 1.0. By default, the Random class uses the current time as the seed value. However, you can also specify a seed value explicitly to generate the same sequence of random numbers.

Method 2: Generating Random Numbers within a Range

In many scenarios, we need random numbers within a specific range. The Random class provides an overloaded Next() method to accomplish this:

int min = 1;
int max = 100;
int randomInRange = random.Next(min, max); // Generate a random integer within the specified range

The Next(min, max) method generates a random integer greater than or equal to min and less than max. By adjusting the values of min and max, you can generate random numbers within any desired range

Method 3: Generating Random Numbers Using CryptoServiceProvider

If you require more secure random numbers for cryptographic purposes, you can use the RNGCryptoServiceProvider class from the System.Security.Cryptography namespace. This class utilizes the cryptographic service provider to generate random numbers with a higher degree of randomness. Here’s an example:

using System.Security.Cryptography;
byte[] randomBytes = new byte[4];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(randomBytes);
int secureRandomNumber = BitConverter.ToInt32(randomBytes, 0);

In this example, we generate a 32-bit random number by obtaining four random bytes using GetBytes() method and converting them to an integer using BitConverter.ToInt32().

Generating random numbers is a common task in many programming scenarios. In C#, you can utilize the Random class for general-purpose random number generation, specifying ranges as needed. For more secure random numbers, the RNGCryptoServiceProvider class is recommended. With these methods at your disposal, you can easily generate random numbers in your C# applications for a wide range of purposes.

How To: Move Windows 11 Taskbar/Start Menu Back to the Left

Sun, 30 Oct 2022 20:47:13 +0000

As we all know, Windows 11 introduced the new centre aligned taskbar. The very first thing that most people wanted to do was move it back to the left, but it does not seem to be immediately obvious how to do so.

It is actually quite simple when you know how:

Right click on the taskbar
Click “taskbar settings”
Click to expand “taskbar behaviours”
Scroll down to “taskbar alignment”
Change “Centre” to “Left”
DONE!

Or watch the youtube video below:

Native pico-sdk ILI9341/ILI9342 display drivere library for Raspberry Pi Pico in C++

Mon, 19 Sep 2022 20:08:23 +0100

The ILI9341/ILI9342 works as display driver for a TFT display, and is available as either a standalone IC, or as a breakout board and is usually conntected up via SPI. I have added a ILI9341 raspberry pi pico library as part of my group of libraries at the pico-libs repository on github.

The library is easy to use and is easily includable in your project via cmake, and libraries are added in, in the same way that you add in the individual libraries from the pico-sdk its self.

You will first need to check out the pico-libs repository, and then copy external/pico_libs_import.cmake from the repository to the root of your firmware application.

You can add the library from the pico-lib’s adding ili934x onto the end of your target_link_libraries in cmake:

target_link_libraries([your executable] pico_stdlib ili934x)

You can then include “ili934x.h” and use the following methods from the ili934x class.

setRotation(ILI934X_ROTATION rotation = R0DEG)
- set the rotation of the display
setPixel(uint16_t x, uint16_t y, uint16_t colour)
- set the value of an individual pixel
fillRect(uint16_t x, uint16_t y, uint16_t h, uint16_t w, uint16_t colour)
- fill a rect defined by x, y, h and w
drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color)
- draw a line from any point, to any other point
drawCircle(uint16_t x0, uint16_t y0, uint16_t r, uint16_t color)
- draw a circle, specifying the centre and the radius
clear(uint16_t colour = COLOUR_BLACK)
- clear the whole screen
blit(uint16_t x, uint16_t y, uint16_t h, uint16_t w, uint16_t *bltBuf)
- draw a set of RGB data defined by h and w, to the position x and y
drawChar(uint16_t x, uint16_t y, char c, uint16_t colour, GFXfont *font)
- draw a single character on screen
charBounds(char c, int16_t *x, int16_t *y, int16_t *minx, int16_t *miny, int16_t *maxx, int16_t *maxy, GFXfont *font)
- measure the size of an individual character
textBounds(const char *str, int16_t x, int16_t y, int16_t *x1, int16_t *y1, uint16_t *w, uint16_t *h, GFXfont *font)
- measure the size of a string of text

All in native C++ with the pico-sdk.

Native pico-sdk mpu6050 accelerometer and gyroscope library for Raspberry Pi Pico in C++

Mon, 19 Sep 2022 20:08:23 +0100

The mpu6050 works as an accelerometer and gyroscope, and is available as either a standalone IC, or as a breakout board and is usually conntected up via I2C (IIC, ICC or I²C or SPI, depending on your preference). I have added a mpu6050 raspberry pi pico library as part of my group of libraries at the pico-libs repository on github.

The library is easy to use and is easily includable in your project via cmake, and libraries are added in, in the same way that you add in the individual libraries from the pico-sdk its self.

You will first need to check out the pico-libs repository, and then copy external/pico_libs_import.cmake from the repository to the root of your firmware application.

You can add the library from the pico-lib’s adding mpu6050 onto the end of your target_link_libraries in cmake:

target_link_libraries([your executable] pico_stdlib mpu6050)

You can then include “mpu6050.h” and use the following methods from the mpu6050 class.

getEvent(sensors_event_t *accel, sensors_event_t *gyro, sensors_event_t *temp)
- Getting the accelerometer values
- the gyroscope values
- and the temperature values

All in native C++ with the pico-sdk.

Native pico-sdk BMP280 temperature sensor and air pressure sensor library for Raspberry Pi Pico in C++

Sun, 18 Sep 2022 22:38:46 +0100

The BMP280 works as an ambient temperature sensor and air pressure sensor, and is available as either a standalone IC, or as a breakout board and is usually conntected up via I2C (IIC, ICC or I²C, depending on your preference). I have written a bmp280 raspberry pi pico library as part of a group of libraries over at the pico-libs repository on github.

The library is easy to use and is easily includable in your project via cmake, and libraries are added in, in the same way that you add in the individual libraries from the pico-sdk its self.

You will first need to check out the pico-libs repository, and then copy external/pico_libs_import.cmake from the repository to the root of your firmware application.

You can add the library from the pico-lib’s adding bmp280 onto the end of your target_link_libraries in cmake:

target_link_libraries([your executable] pico_stdlib bmp280)

You can then include “bmp280.h” and use the following methods from the BMP280 class.

readTemperature();
readPressure(void);
readAltitude(float seaLevelhPa = 1013.25);
seaLevelForAltitude(float altitude, float atmospheric);
waterBoilingPoint

C# Basics - Deep Copy Object Tree

Fri, 01 Jul 2022 11:26:06 +0100

Object deep copy is a process of creating a new object instance that is an exact copy of another object. This process includes creating a new object with all the same properties and values as the original object. Object deep copy is usually used to avoid creating unwanted references between objects, or to create a separate object instance that can be modified without affecting the original object.

There are several ways to create a deep copy of an object in C#. One way is to use the System.Reflection.MemberInfo.Copy method. This method copies all the public and private members of an object to a new object instance. Another way to create a deep copy is to use the binary serialization mechanism in C#. This approach requires the object to be serialized and deserialized, which can be expensive.

The System.Object.MemberwiseClone method can also be used to create a deep copy of an object. This method copies all the fields of an object to a new object instance. However, this method does not copy the properties of the object. Therefore, it is not a complete deep copy.

Here is an example of how to create a deep copy using the System.Reflection.MemberInfo.Copy method:

public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main(string[] args)
{
Person person1 = new Person();
person1.Name = "John";
person1.Age = 20;
Person person2 = (Person)person1.Copy();
Console.WriteLine(person2.Name); // John
 Console.WriteLine(person2.Age); // 20
 }
}

In the example above, we first create a Person class with two properties: Name and Age. We then create an instance of the Person class and assign values to the Name and Age properties. Next, we create a deep copy of the person1 object using the Copy method. Finally, we print out the values of the Name and Age properties of the person2 object to the console. As we can see, the values are exactly the same as the original object.

Here is an example of how to create a deep copy using the binary serialization mechanism:

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main(string[] args)
{
Person person1 = new Person();
person1.Name = "John";
person1.Age = 20;
Person person2 = null;
using (MemoryStream stream = new MemoryStream())
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, person1);
stream.Seek(0, SeekOrigin.Begin);
person2 = (Person)formatter.Deserialize(stream);
}
Console.WriteLine(person2.Name); // John
 Console.WriteLine(person2.Age); // 20
 }
}

In the example above, we use the BinaryFormatter class to serialize and deserialize the object. We first serialize the object to a memory stream. We then seek the stream to the beginning and deserialize it to the person2 object. Finally, we print out the values of the Name and Age properties of the person2 object.

Here is an example of how to create a deep copy using the System.Object.MemberwiseClone method:

public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main(string[] args)
{
Person person1 = new Person();
person1.Name = "John";
person1.Age = 20;
Person person2 = (Person)person1.MemberwiseClone();
Console.WriteLine(person2.Name); // John
 Console.WriteLine(person2.Age); // 20
 }
}

In the example above, we use the MemberwiseClone method to create a deep copy of the Person object. This method copies all the fields of the object to a new object. However, it does not copy the properties of the object. Therefore, it is not a complete deep copy.

C# Basics: Loop Through a Dictionary

Wed, 27 Apr 2022 11:25:28 +0100

Dictionaries are essential data structures in C# that allow you to store key-value pairs. Looping through dictionaries enables you to iterate over each key-value pair and perform operations on them. In this article, we will explore different methods of looping through dictionaries in C# and discuss their applications.

Method 1: Using foreach Loop

The simplest and most common way to iterate through a dictionary is by using a foreach loop. The foreach loop automatically enumerates the key-value pairs of the dictionary. Here’s an example

Dictionary<string, int> dictionary = new Dictionary<string, int>()
{
{ "Apple", 5 },
{ "Banana", 3 },
{ "Orange", 8 }
};
foreach (KeyValuePair<string, int> kvp in dictionary)
{
string key = kvp.Key;
int value = kvp.Value;
// Perform operations with key-value pairs
 Console.WriteLine("Key: " + key + ", Value: " + value);
}

In this example, we have a dictionary containing fruit names as keys and their respective quantities as values. The foreach loop iterates through each key-value pair, allowing you to access the key and value individually for further processing.

Method 2: Using Keys or Values Collection

If you only need to access either the keys or values of a dictionary, you can use the Keys or Values property to obtain a collection and loop through it. Here’s an example:

Dictionary<string, int> dictionary = new Dictionary<string, int>()
{
{ "Apple", 5 },
{ "Banana", 3 },
{ "Orange", 8 }
};
foreach (string key in dictionary.Keys)
{
// Accessing keys only
 Console.WriteLine("Key: " + key);
}
foreach (int value in dictionary.Values)
{
// Accessing values only
 Console.WriteLine("Value: " + value);
}

In this example, we loop through the Keys collection to access and print each key individually. Similarly, we loop through the Values collection to access and print each value separately.

Method 3: Using LINQ

LINQ (Language-Integrated Query) provides a powerful and concise way to query and manipulate data in C#. You can use LINQ to loop through dictionaries and apply various operations. Here’s an example:

Dictionary<string, int> dictionary = new Dictionary<string, int>()
{
{ "Apple", 5 },
{ "Banana", 3 },
{ "Orange", 8 }
};
var sortedDictionary = dictionary.OrderBy(x => x.Key);
foreach (var kvp in sortedDictionary)
{
string key = kvp.Key;
int value = kvp.Value;
// Perform operations with key-value pairs
 Console.WriteLine("Key: " + key + ", Value: " + value);
}

In this example, we use LINQ’s OrderBy() method to sort the dictionary by keys in ascending order. Then, we loop through the sorted dictionary and access each key-value pair for further processing.

Looping through dictionaries in C# allows you to access and manipulate key-value pairs efficiently. The foreach loop is the most common method, providing direct access to both the keys and values. Alternatively, you can loop through the Keys or Values collection if you only need one of them. Additionally, LINQ provides a powerful way to query and manipulate dictionaries. With these methods, you can effectively iterate through dictionaries and perform operations on their contents in your C# applications.

C# Basics: What is the difference between 'string' and 'System.String'

Wed, 27 Apr 2022 11:25:13 +0100

In C# string is an alias for System.String, So technically, there is no difference and they are exactly the same as comparing int and System.Int32, they will compile to exactly the same code. but…

There is a complete list of all aliases to primative types (not all are primitive actually):

object: System.Object
string: System.String
bool: System.Boolean
byte: System.Byte
sbyte: System.SByte
short: System.Int16
ushort: System.UInt16
int: System.Int32
uint: System.UInt32
long: System.Int64
ulong: System.UInt64
float: System.Single
double: System.Double
decimal: System.Decimal
char: System.Char

Besides string and object all of the aliases are value types. Although decimal is a value type it is not a primitive type in the CLR. System.IntPtr is the only primitive type which doesn’t have an alias in C#.

These value type aliases are known as “simple types” in the C# spec, and literals can be used for constant values of every simple type.

With all that said, there is one time where you have to use the aliases: when explicitly specifying an enum’s type:

public enum BadClass : UInt32 {} // Invalid
public enum GoodClass : uint {} // Valid

That’s is simply down to the way the spec defines enums - the part after the colon has to be the integral-type, which is one of sbyte, byte, short, ushort, int, uint, long, ulong, char, as opposed to a type as with variable declarations.

When it comes down to which you should use, it does not matter, any of the aliases or their underlaying types will be compiled down to the same MSIL or binary code.

C Sharp 11 Raw String Literals

Mon, 25 Apr 2022 22:59:26 +0100

If you work with literal strings that can contain quotes or language strings such as JSON, XML, HTML, SQL or Regex, raw literal strings may be the best new feature of C# 11.

If you previously copied a literal string with quotes into a C# literal string, the string ended at the first double quote with compiler errors until you escaped each of the double quotes. If you copied text with curly braces into an interpolated string literal, each curly bracket was interpreted as the beginning of nested code unless you escape each curly bracket by doubling each curly bracket.

Raw string literals have no escaping. A backslash is output as a backslash, a curly bracket is output as a curly bracket and \n is output as the backslash and an n, not a new line.

Raw string literals start and end with at least three double quotes ("""..."""). Within these double quotes, single " are considered content and included in the string. Any number of double quotes less than the number that opened the raw string literal are treated as content. So, in the common case of three double quotes opening the raw string literals, two double quotes appearing together would just be content. If you need to output a sequence of three or more double quotes, just open and close the raw string literal with at least one more quote than that sequence.

Raw string literals can be interpolated by preceding them with a $. The number of $’s that prefix the string is the number of curly brackets that are required to indicate the nested code expression. This means that a $ behaves like the existing string interpolation – a single set of curly brackets indicate nested code. If a raw string literal is prefixed with $$, a single curly bracket is treated as content and it takes two curly brackets to indicate nested code. Just like with quotes, you can add more $ to allow more curly brackets to be treated as content.

Read more in the raw string literals documentation.

Why You Should Use Oauth OAuth 2.0 Tokens

Thu, 14 Apr 2022 21:25:28 +0100

An OAuth 2.0 access token is usually a base64 encoded string that the client uses when making requests to the server, and can hides the user’s identity and other personal information from the client app/website and anybody listening in on the line.

Access tokens expire after a certain amount of time and become invalid and cannot be used for any API request after the expiration date/time. If offline access is requested to the for the token, you can refresh an access token without prompting the user for permission, even when the user is not present.

It is best to set the expiration time for refresh token longer than the expiration of the access tokens its self. For example, if you set the expiration for the access token to 30 minutes, set the refresh token’s expiration to 24 hours or more (depending on when you expect a user to next use the service).

Some apps may request that the user reauthenticate after a shorter period of time, which relies on the access token alone rather than a refresh token. These apps have online access as opposed to those that have a refresh token and are considered to have offline access.

Observe/React to Array Changes with Angular 12

Mon, 11 Apr 2022 22:37:34 +0100

In angular 12, it is very simple to have the HTML of your component react to changes in the value of a single variable (or multiple variables). Although it is not that simple when you want to have your components HTML react to push/pop changes.

Take the following component:

export class TitleComponent implements OnInit {
title: string = "default title";
constructor() { }
ngOnInit(): void {
this.title = "some title"
}
changeTitle(): void {
this.title = "new title";
}
}

<div>
<h3><span>{{ title }}</span></h3>
</div>
<button (click)="changeTitle()">CLICK ME!</button>

If you click the “change” button, the title will change as expected because Angular 12 watches all of your component variables for changes and reflect those changes within the HTML.

However, if you take the next component, you will find that the same thing does not happen and the HTML does not update, since angular is not able to monitor changes to an array via push/pop.

export class StringListComponent implements OnInit {
items: string[] = [];
constructor() { }
ngOnInit(): void {
this.items = ["first item"];
}
addItem(): void {
this.items.push("new item");
}
}

<div *ngFor="let item of items">
<div><span>{{ item }}</span></div>
</div>
<button (click)="addItem()">CLICK ME!</button>

There is a very simple fix to have angular 12 react to array changes. You simply need to recreate the array for each update as below.

export class StringListComponent implements OnInit {
items: string[] = [];
constructor() { }
ngOnInit(): void {
this.items = ["first item"];
}
addItem(): void {
this.lists = [...this.items, "new item"];
}
}

uTP Micro Transport Protocol Documented

Mon, 04 Oct 2021 23:54:05 +0100

While updating my bittorrent library, I found that the uTP (Micro Transport Protocol) documentation is quite lacking, unless you already know how the protocol works, so here is my attempt to expand on the documentation that already exists in an effort to provide more information on implementing uTP.

Information from BEP 29, bittorrent/libutp at github and from reverse engineering based on Wireshark UDP dumps.

Notes

uTP uses window based congestion control. Each socket has a max_window which determines the maximum number of bytes the socket may have in-flight at any given time. Any packet that has been sent, but not yet acked, is considered to be in-flight

uTP Packet Header Format

All fields are in network byte order (big endian).

0 4 8 16 24 32 (bits)
+-------+-------+---------------+---------------+---------------+
| type | ver | extension | connection_id |
+-------+-------+---------------+---------------+---------------+
| timestamp_microseconds |
+---------------+---------------+---------------+---------------+
| timestamp_difference_microseconds |
+---------------+---------------+---------------+---------------+
| wnd_size |
+---------------+---------------+---------------+---------------+
| seq_nr | ack_nr |
+---------------+---------------+---------------+---------------+

type

packet type, and is one of the following 4 bit ints

Name	id	Description
ST_DATA	0	regular data packet, always has a payload
ST_FIN	1	Finalize the connection, is the last packet. seq_nr of this packet will be the last packet expected (though earlier packets may still be in flight)
ST_STATE	2	State packet, used to transmit an acknowledgement of a packet, does not increase the seq_nr
ST_RESET	3	Force closes the connection
ST_SYN	4	Connect/Sync packet, seq_nr is set to 1, connection_id is randomised, all subsequent packets sent on this connection are sent with the connection_id + 1

version

protocol version, is always set to 1 and stored as a 4 bit int

connection_id

This is a random, unique, 16 bit int, identifying all the packets that belong to the same connection. Initial packet is sent with this number, all subsequent packets are sent with connection_id + 1

extension

not currently used in this library, always set to a 8 bit int of 0

timestamp_microseconds

The timestamp in microseconds when the packet was sent, this should be as close to the actual transmit time as possible

timestamp_difference_microseconds

Initialised as 0 for the ST_SYN packet, subsequent packets set this to the current timestamp in microseconds, minus the timestamp_microseconds of the last received packet.

wnd_size

32 bit int specificied in bytes. This is the number of bytes currently sent, but not yet ACK-ed with a ST_STATE. When sending any packets to the remote peer, this must be set to the number of bytes left in the sockets receive buffer.

seq_nr

16 bit int, initialised to 1 or any random positive number. incremented by 1 for each packet sent except for when receiving ST_STATE, serves as an order number for the receiving end.

ack_nr

The seq_nr from the last packet received, unless it is the first ST_SYN, then it is seq_nr - 1.

Congestion Control

Congestion Control uses ledbat congestion control and uses a calculated max_window and also uses wnd_size where max_window is initialised to INT_MAX.

const CCONTROL_TARGET = 100 * 1000 // 100ms in microseconds
const MAX_CWND_INCREASE_BYTES_PER_RTT = 3000
const MIN_WINDOW_SIZE = 10
const MAX_WINDOW_DECAY = 100 * 1000
var current_msec = current_microseconds()
var target = CCONTROL_TARGET
if (target <= 0) target = CCONTROL_TARGET
var min_rtt = min(min_rtt, current_msec - last_received_packet.timestamp)
var our_delay = min(min(our_history), min_rtt)
var off_target = target - our_delay
var window_factor = min(bytes_acked, max_window) / max(max_window, bytes_acked)
var delay_factor = off_target / target
var scaled_gain = MAX_CWND_INCREASE_BYTES_PER_RTT * window_factor * delay_factor
if (scaled_gain + max_window < MIN_WINDOW_SIZE) {
max_window = MIN_WINDOW_SIZE
} else {
max_window = max_window + scaled_gain
}
max_window = max_window < MIN_WINDOW_SIZE ? MIN_WINDOW_SIZE : (max_window > socket_send_buff_size ? socket_send_buff_size : max_window) // set new max window
// max_window is now the maximum number of bytes that can be sent with this packet
//can we decay the max_window?
if(current_msec - last_decay_msec >= MAX_WINDOW_DECAY) {
max_window = max_window * 0.5
last_decay_msec = current_msec
if(max_window < MIN_WINDOW_SIZE) {
max_window = MIN_WINDOW_SIZE
}
}

Example Transaction

Local peer sends
- type = ST_SYN
- ver = 1
- extension = 0
- connection_id = 12345 //random number
- timestamp_microseconds = 123456789000
- timestamp_difference_microseconds = 0
- wnd_size = 0
- seq_nr = 1
- ack_nr = 0
Remote peer receives and decodes the header, and responds with
- type = ST_STATE
- ver = 1
- extension = 0
- connection_id = 12347 // connection_id from the local peer + 1
- timestamp_microseconds = 133456789000
- timestamp_difference_microseconds = 125000 // difference between when the ST_SYN was sent, and when it was received
- wnd_size = 1000000 // chosen window size
- seq_nr = 1000 // remote peers own sequence number
- ack_nr = 1 // seq_nr from the local peer
Local peer sends
- type = ST_DATA
- ver = 1
- extension = 0
- connection_id = 12347 // connection_id from the remote peer
- timestamp_microseconds = 143456789000
- timestamp_difference_microseconds = 125000 // difference between when the ST_STATE was sent, and when it was received
- wnd_size = 1000000 // chosen window size
- seq_nr = 2 // local peers own sequence number
- ack_nr = 1000 // seq_nr from the remote peer
Remote peer receives and decodes the header, and responds with
- type = ST_STATE
- ver = 1
- extension = 0
- connection_id = 12347 // connection_id
- timestamp_microseconds = 153456789000
- timestamp_difference_microseconds = 125000 // difference between when the ST_DATA was sent, and when it was received
- wnd_size = 1000000 // chosen window size
- seq_nr = 1000 // remote peers own sequence number
- ack_nr = 2 // seq_nr from the local peer

Building a site with Hugo, using GitHub, Amazon S3 and CloudFront with HTTPS and extensionless URLs

Wed, 10 Mar 2021 08:00:00 +0000

This blog, and many others, are hosted using Amazon AWS. This one has a difference, it is almost completely free to host (and was completely free for the first year) because of Hugo, Amazon S3, Cloudfront, lambda@edge, Azure DevOps and (optionally) GitHub.

This site is built using hugo, which is a “website generator” tool that lets you write your pages using markdown, combine that markdown with a theme, and generates a static html website with SEO friendly (optional) extensionless URLs.

You first need to set your local copy of your hugo website, (use the hugo quick start) and add some content/posts.

Now the hugo site is set up, and you have started adding content, we need somewhere to put the site that hugo generates, this is where amazon s3 comes in.

If you do not already have one, sign up for an amazon aws account (its free to sign up).

In your aws account, you will need to create an s3 bucket, and the name of the bucket should be the exact domain name you intend to use as your website domain name, the region would be best to be a region close to you, but as long as its on the same continent, it doesnt really matter. Under “set permissions” you need to uncheck “block all public access” and uncheck all its child check boxes too. Once created, go to properties > static website hosting and unable “use this bucket to host a website”, set the index document to index.html and the error document to error.html and save. This should now give you an amazon s3 url to your bucket. If you upload a temporary index.html document, you should now be able to visit the s3 url and see the index page.

![s3 bucket hosting config][example1]

To have the website automatically built and deployed to your s3 bucket, you will need to set up a git repository (at github, or azure devops).

cd [path to hugo site dir with config.toml]
git init .

Once you have done this, create a GitHub repository, and add the GitHub remote repository and push your code to GitHub.

git remote add origin https://github.com/UserName/Repository.git
git push -u origin master

Next, you want to create a free Azure DevOps account and link it to GitGub. Next, you will want to add the “hugo” and the “aws toolkit for azure devops” extensions to your azure devops account.

Now, create a new build pipeline in Azure DevOps with the agent specification of “windows-2019”. Set “Get Sources” to GitHub and choose the repository that we set up earlier, and choose “master” as the branch.

Then you want your build YAML file to look something like this (vmImage needs to be windows as Hugo in devops does not yet support linux images):

trigger:
- master
pool:
vmImage: 'windows-latest'
steps:
- checkout: self
submodules: true
clean: true
- task: HugoTask@1
displayName: Generate Site
inputs:
source: '$(Build.SourcesDirectory)'
destination: '$(Build.ArtifactStagingDirectory)'
baseURL: 'https://mysite.com/'
- task: PublishBuildArtifacts@1
inputs:
PathtoPublish: '$(Build.ArtifactStagingDirectory)'
ArtifactName: 'content'
publishLocation: 'Container'

Save this YAML file and run a build, you should see that your markdown is pulled from github, and then devops generates your site for you, and uploads it to container storage named “content” within azure devops (be sure that the baseURL matches your baseURL in your hugo config). A new build will be automatically run each time a commit is made to your master branch within github.

Option 1: (Hosted directly on s3 with no SSL)

If you do not want to go through the extra steps of having SSL, and you only want to set up a single website domain, then all you need to do is get your s3 domain from the s3 website setup step, and create a CNAME from the domain (same domain you named the bucket) to the s3 domain.

i.e. www.mysite.com -> CNAME -> www.mysite.com.s3-website-eu-west-1.amazonaws.com (depending on your region that you chose).

Once the new domain has resolved correctly, you are done.

Option 2: (Hosted on s3 with cloudfront and SSL and optionally, multiple domains)

Coming soon :D

IMAP4 Client Protocol Library for C# and .NET

Wed, 13 Jan 2021 18:25:21 +0000

System.Net.Imap4 is an IMAP4 client library for .NET written in C# with support for parsing multipart, attachments, html and plain parts.

It includes:

Plain and Encrypted (SSL/TLS) Connections
Fetching server capabilities
Authentication (Plain only)
Fetching folder lists/Folder selection
Fetching Email Counts
Fetching RAW email
Fetching parsed email
Deleting emails
Authentication (Plain only)
Waiting for emails (push emails)
Setting/Getting flags
Multipart emails
HTML emails
Attachments

Released under the BSD-3-Clause licence, and is also available for use as an easy to use nuget package.

Connect to GMail

static IMapClient ConnectToClient()
{
}

Get email

static EmailMessage GetEmail(int id, IMapClient client)
{
}

Delete email

static EmailMessage DeleteEmail(int id, IMapClient client)
{
}

Get Attachment from email

static void GetAttachments(EmailMessage msg)
{
}

What's New and Interesting in .NET 5

Thu, 15 Oct 2020 21:52:13 +0100

Microsoft recently announced .NET 5 (dotnet5) which is the unification of .NET Framework and dotnet core, leaving behind the divergance, and unifying the whole .NET platform.

Why .NET 5 and not dotnet core 4.0

Given that Microsoft have already released .NET Framework 4.0 several years ago, they decided the best idea would be to skip the 4.0 release with dotnet core to avoid confusing users (which they did for sort of the same reason in Windows 10), and they landed on .NET 5.0, unifying the names and the numbers from Framework and core.

The Unified Platform

.NET 5 will be able to target Windows, Linux, macOS, iOS, Android, tvOS, watchOS and WebAssembly. Building on top of dotnet core and the best of mono to create a platform that will allow developers to create apps for multiple operating systems and devices from a single codebase and a single framework.

Runtime

CoreCLR is the runtime that is used in dotnet core, and has been targeted at cloud and web applications, and more recently, desktop applications and IoT devices.

Mono is the original cross platform runtime that was designed to be compatible with .NET. It started out as an alternitive, but was later brought into the fold of the mainstream platform and is at the core of Xamarin.

With .NET 5 and .NET 6 in the future, Microsoft aims to have CoreCLR and Mono be fully interchangable with each other, i.e. a .NET application can run the same on either runtime.

RyuJIT (the assembly code generator)

There are many enhancements in RyuJIT, such as enabling the suppression of some bounds checks, tail duplication improvements and removal of redundant zero inits. RyuJIT also implements ARM64 hardware intrinsics, creating smaller and faster code when building for AMD64 targets.

Garbage collection

Garbage collection will now expose detailed data on the most recent collection, developers can use the GetGCMemoryInfo method, which will return a GCMemoryInfo object. The GCMemoryInfo object contains information about machine memory, heap memory and the most recent collection, or the most recent specified collection such as: ephemeral, full blocking, or background. The main use for this would be logging/monitoring and to communicate to a load balancer that a machine should be taken out of rotation.

System.Text.Json

The new System.Text.Json allows the user the ability to ignore default values for value type properties when serializing, reducing resource costs (both CPU and network), this is a breaking change for System.Text.Json, but is a welcome change. System.Text.Json also has ways of dealing with circular references when serializing.

What else?

When .NET 5 hits production release in november 2020, we expect to see cross platform support (full or partial) for:

ASP.NET Core, an open source framework for web applications.
Entity Framework Core data access technology.
WinForms.
WPF (Windows Presentation Foundation).
Xamarin mobile app device model.
ML.NET.

As well as:

C# 9 and F# 5 language support
Improved HTTP 1.1 and HTTP 2 performance
Single file applications (linking all assemblies into a single exe)

Take a look at the microsoft dotnet website for downloads and more information.

C# Console Async Main - Async Entry Point for Console Apps

Wed, 14 Oct 2020 09:00:00 +0100

As of C# 7.1, it is possible with console apps, to have async all the way to the entry point. The previous constraints of the entry point have been the same all the way up to this point, and similar to the entry point in C/C++ apps. The C# entry point method must be static, the name of the method must be Main, the return type must be either void or int and finally, the method can accept zero arguments, or exactly one argument of string[], which contains the command arguments.

Given those limitations, the 4 possible entry points before C# 7.1 are:

public static void Main();
public static int Main();
public static void Main(string[] args);
public static int Main(string[] args);

If we wanted to mimic async all the way to the core, we would have to do something like this:

public static int Main(string[] args)
{
return MainAsync(args).GetAwaiter().GetResult();
}
public static async Task<int> MainAsync(string[] args)
{
//do async main
}

While this works, it looks dirty, and is an extra step we shouldnt need to be taking.

C# 7.1

Now that we have C# 7.1, we get these new possible entry points for a console app. You also have the option of having the async keyword on each of these new entry points.

public static Task Main();
public static Task<int> Main();
public static Task Main(string[] args);
public static Task<int> Main(string[] args);

With C# 7.1, this makes async Main much easier, and much simpler and much better, and allows us to write apps that are console based that are async all the way down to the entry point, making for much more scope to create console apps without deadlocks, and without waiting for tasks that are CPU bound.

Problems With Copying a Stack in C# and How to Fix It

Tue, 13 Oct 2020 09:35:53 +0100

In C# and in .NET in general, there is a generic stack class which accepts a single type parameter. The stack class is a FILO (first in last out) collection, and can be liked to stacking plates, you cannot remove the bottom plate, without first removing all the plates above it. The problem with the Stack<T> class is that it has an IEnumerable<T> constructor…

This constructor suggests that whatever collection is passed to it, is copied exactly to the new stack. The problem is, it is both true and not true at the same time, especially if you are copying another stack.

If you pass a stack to another stack and expect to have the same stack twice, you will start to run into problems.

If we init a stack like this:

var firstStack = new Stack<int>();
firstStack.Push(1);
firstStack.Push(2);
firstStack.Push(3);

You will end up with 1 at the bottom of the stack, 2 on top of 1 and then 3 at the top of the stack.

If you then want to copy that stack to another stack, you would assume this is correct:

var secondStack = new Stack<int>(firstStack);

You would assume that secondStack would also end up with 1 at the bottom of the stack, 2 on top of 1, and 3 at the top of the stack, but this is wrong. What actually happens is the reverse of this. 3 ends up at the bottom of the stack, 2 in the middle and 1 at the top.

The reason for this is that in converting the Stack<T> to an IEnumerable<T>, what essentially happens is, the old stack is itterated from top to bottom, rather than bottom to top. This has the effect of the last item added to the first stack, becoming the first item that is added to the new stack, essentially reversing the stack in the copy.

To get around this, the most simple option when copying a stack, is to double copy the stack (though with large stacks, this is not the most efficient), and an extension method for doing this can be as follows:

public static Stack<T> Clone<T>(this Stack<T> originalStack)
{
return new Stack<T>(new Stack<T>(originalStack));
}

This has the effect of reversing the stack, and then reversing it again in a second copy. The inner stack and its items will be released by the GC very quickly, and we now have a method which we can use to clone a Stack<T>.

Simple C++ Neural Network Library

Sun, 11 Oct 2020 09:58:35 +0100

The C++ library (source on github) is designed to be a core neural network library, implementing basic neurons, layers and networks and comes with some basic learning methods too. The library is complete enough for those who want to learn and understand neural networks and how they are put together, but by no means is intended to be a complete AI library.

(Originally based On Neural Networks on C#)

Main Classes

Neuron - An abstract base class for all neurons. Encapsulates entities like a neuron’s weight, output value, and input value. Other neuron classes inherit from the base class.
Layer - A collection of neurons. This is a base abstract class, which encapsulates common functionality for all neuron’s layers.
Network - A collection of layers. This is an abstract base class for a layered neural network.
IActivationFunction - Pure virtual interface for activation functions. Activation functions are used in activation neurons - the type of neuron, where the weighted sum of its inputs is calculated and then the value is passed as input to the activation function, and the output value becomes the output value of the neuron.
IUnsupervisedLearning - Pure virtual interface for an unsupervised learning algorithms - the type of learning algorithms where a system is provided with sample inputs only during the learning phase, but not with the desired outputs.
ISupervisedLearning - Pure virtual interface for a supervised learning algorithms - this type of learning algorithms where a system is provided with sample inputs, with desired output values during the learning phase.

Architecture

Activation Network - The neural network where each neuron computes its output as the activation function’s output, and the argument is a weighted sum of its inputs combined with the threshold value. The network may consist of a single layer, or of multiple layers. Trained with supervised learning algorithms, the network allows to solve such tasks as approximation, prediction, classification, and recognition.
Distance Network - The neural network where each neuron computes its output as a distance between its weight values and input values. The network consists of a single layer, and may be used as a base for such networks like Kohonen Self Organizing Map, Elastic Network, and Hamming Network.

Learning

Different learning algorithms are used to train different neural networks, and are used to solve different problems:

Perceptron Learning - the algorithm may be considered as the first neural network learning algorithm, and its history starts from 1957. The algorithm may be used with a one-layer activation network, where each neuron has a threshold activation function. The range of its applications are rather small and limited the with classification of linearly separable data.
Delta Rule Learning - the algorithm is a next step after the perceptron learning algorithm. It utilizes the activation function’s derivative, and may be applicable to single-layer activation networks only, where each neuron has a continuous activation function instead of a threshold activation function. The most popular continuous activation function is the unipolar and bipolar sigmoid function. Because the algorithm may be applied to one-layer networks only, it is limited to some classification and recognition tasks mostly.
Back Propagation Learning - this is one of the most popular and known algorithms for multi-layer neural network learning. Initially, it was described in 1974, and from that time, it was extensively studied and applied to a broad range of different tasks. Because the algorithm is able to train multi-layer neural networks, the range of its applications is very great, and includes such tasks as approximation, prediction, object recognition, etc.
SOM Learning - this algorithm was developed by Kohonen, and may be considered as one of the most famous unsupervised learning algorithms for clusterization problems. It treats neural network as a 2D map of nodes, where each node may represent a separate class. The algorithm organizes a network in such a way, that it becomes possible to find the correlation and similarities between data samples.
Elastic Network Learning - the algorithm is similar to the idea of the SOM learning algorithm, but it treats network neurons not as a 2D map of nodes, but as a ring. During the learning procedure, the ring gets some shape, which represents a solution. One of the most common demonstrations of this learning algorithm is the Traveling Salesman Problem (TSP).

dotnet BitTorrent library written in C#

Fri, 09 Oct 2020 23:00:00 +0100

System.Net.Torrent is an open source bittorrent scraper and peer wire implementation written in C#

It includes:

Tracker Announce (HTTP/UDP)
Tracker Scrape (HTTP/UDP)
PeerWire (TCP) Client
Choke
Unchoke
Interested
Not Interested
Have
Bitfield (Optional obsfucation)
Request
Piece
Fast Protocol Extensions
Extended Protocol Extensions
Local Peer Discovery (Non-existant Multicast BEP-14)
Peer Exchange (utPEX)
Trackerless Metadata (utMetadata)
Magnet Link Parser
Bencode Encode/Decode
.torrent Metadata Parser
Tracker Exchange Protocol

Resolving a magnet link to metadata (.torrent file)

static void TestAsyncMagnetLink()
{
var ubuntuMagnetLink = "magnet:?xt=urn:btih:e4be9e4db876e3e3179778b03e906297be5c8dbe&dn=ubuntu-18.04-desktop-amd64.iso&tr=http://torrent.ubuntu.com:6969/announce";
var magnetMetadata = MagnetLink.ResolveToMetadata(ubuntuMagnetLink);
foreach (var item in magnetMetadata.AnnounceList)
{
Console.WriteLine(item);
}
}

Scraping announce/tracker URLs

static void ScrapeTorrent()
{
var scraper = new HTTPTrackerClient(15);
var announce = scraper.Scrape("http://torrent.ubuntu.com:6969/announce", new string[] { "e4be9e4db876e3e3179778b03e906297be5c8dbe" });
}

Announce (request peers from the tracker)

static void AnnounceTorrent()
{
var scraper = new HTTPTrackerClient(15);
var peers = scraper.Announce("http://torrent.ubuntu.com:6969/announce", "e4be9e4db876e3e3179778b03e906297be5c8dbe", "-LW2222-011345223110");
}

Creating Windows and Linux background services in dotnet core 3.0/3.1

Thu, 30 Apr 2020 19:00:00 +0100

There are times when you need an application to just sit there in the background and deal with the same repetitive task over and over again.

In dotnet core 3.0, a new type of template was introduced, “Worker Service”, which is a very easy way of creating Windows Services and Linux Daemons.

The Basics

The new “worker” template can be accessed in one of two ways:

via the command line

mkdir myNewWorker
cd myNewWorker
dotnet new worker

via Visual Studio

Either way, you end up with the same basic template to start with, which is your Startup class, and your Worker class.

The Startup Class

The startup class is your entry point to the executable In the initial template, we are

public static IHostBuilder CreateHostBuilder(string[] args)
{
return Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService<Worker>();
});
}

The first thing we need to do is add the generic host library nuget package Microsoft.Extensions.Hosting and switch the SDK to the worker SDK.

You can do this by opening up your csproj file and making the following changes:

<Project Sdk="Microsoft.NET.Sdk.Worker">
<PropertyGroup>
<TargetFramework>netcoreapp3.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Hosting" />
</ItemGroup>
</Project>

Next, we need to add the following lines to our CreateHostBuilder.

public static IHostBuilder CreateHostBuilder(string[] args)
{
return Host.CreateDefaultBuilder(args)
.UseSystemd()
.UseWindowsService()
.ConfigureServices((hostContext, services) =>
{
services.AddHostedService<Worker>();
});
}

The Worker class

Lastly, we can create our background service worker class, which is executed asynchronously, has logging, and has configuration built in too.

 public class Worker : BackgroundService
{
private readonly ILogger<Worker> _logger;
private readonly IConfiguration configuration;
public Worker(ILogger<Worker> logger, IConfiguration configuration)
{
_logger = logger;
this.configuration = configuration;
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
await Task.Delay(1000, stoppingToken);
}
}
}

dotnet Core and C# Dependency Injection

Fri, 24 Apr 2020 11:00:00 +0000

This is a short introduction into Dependency Injection for those who are new to dotnet core and C#, with an attempt to explain what it is, and how it works.

So, what is Dependency Injection?

DI is a programming method that makes each class independent of the other classes around it. Meaning that we don’t rely on our dependencies working exactly how we expect, and only rely on the API being there to use.

What’s the point?

The two main advantages are:

Flexibility: The implementation of each dependency can be switched for any other implementation, as only the interface is required by each class.
Testability: Relying only on interfaces allows us to test individual classes on their own without relying on any of the dependencies, making testing simpler and more straight forward.

How to use it in dotnet core?

Fortunately, dotnet core has a built in Dependency Injection engine (referred to as DI, or IoC or Inversion of Control), in fact, it is used by many of the internal dotnet core services and frameworks. The best thing, is that it all exists within Microsoft.Extensions.DependencyInjection, which can be added via nuget if you do not already have it in your project.

How do we know what is and is not a service we should register?

It is quite simple, and there are a few “rules” to help you figure it out:

Lifespan within the scope: Are we instantiating the service in the scope of the method?
Multiple versions, Is there be more than one (possible) version of this service?
Testing, really, you only want to test one specific method at a time. If you have code that does many other things, you should to move that to a dedicated service. This moved code would then become a dependency its self.
Output, i.e accessing a network resource, doing an API call or interacting with I/O - then it should be placed in a separate service and be injected in as a dependency.

Example

public void CompletePurchase(double amount, string cardNumber, string address, string city, string name)
{
var paymentService = new PaymentService();
var successfullyCharged = paymentService.Charge(int amount, cardNumber);
if (successfullyCharged)
{
var shippingService = new ShippingService();
shippingService.Ship(address, city, name);
}
}

The problems with the above code are:

The first problem is that we directly instantiate PaymentService and ShippingService, so we risk triggering a HTTP call when trying to test
We would have to include test code for PaymentService and ShippingService, or all code paths would not be fully tested
We do not control this code due to the external code paths

What we should be doing is injecting the services via the class constructor, allowing us to swap out the implementations at will, with new implementations or with mock implementations.

public class Checkout
{
private IPaymentService _paymentService;
private IShippingService _shippingService;
public Checkout(IPaymentService paymentService, IShippingService shippingService)
{
_paymentService = paymentService;
_shippingService = shippingService;
}
public void CompletePurchase(double amount, string cardNumber, string address, string city, string name)
{
var successfullyCharged = _paymentService.Charge(int amount, cardNumber);
if (successfullyCharged)
{
_shippingService.Ship(address, city, name);
}
}
}

This code now:

Is only concerned about one thing, converting a charge into a shipment (where the actual charge, and shipping are performed by another service)
We control the entirity of this code
We can swap out different implementations of IPaymentService and IShippingService allowing us to create mock implementations so that we can test just CompletePurchase in isolation.

Enter dotnet core

The built-in container is represented by an IServiceProvider implementation that supports constructor injection by default. The classes managed by the built-in IoC container are called services.

ASP.NET Core allows us to register our application services with IoC container, in the ConfigureServices method of the Startup class. The ConfigureServices method includes a parameter of the IServiceCollection interface which is used to register application services

public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.Add(new ServiceDescriptor(typeof(IPaymentService), new PaymentService()));
services.Add(new ServiceDescriptor(typeof(IShippingService), new ShippingService()));
}
}

So IoC and DI in ASP.NET Core and dotnet core in general is very easy, and more or less built in.

dotnet core 3.0 Self Contained Single Executable (and other build optimisations)

Tue, 21 Apr 2020 23:36:31 +0100

Applications feel more optimised when their binaries, or set of binaries are small. With dotnet core 3.0 there are some features built in that help facilitate this.

Specify the build target

First of all, you should specify your build target for your release builds, this will create a binary specifically optimised and targeted for that platform.

A non-exhaustive list of possible runtime targets are: win-x64, win-x86, win-arm, win-arm64, linux-x64, linux-arm, osx-x64. (The full list can be found on the microsoft runtime id catalog)

dotnet publish -r win-x64 -c release

Publish Trimmed

Publishing in trimmed mode, the dotnet core compiler attempts to work out which assemblies will actually be used, and which will not, and removes all unused assemblies from the published output.

To do this, you will need to add a single xml block to your csproj file.

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netcoreapp3.0</TargetFramework>
<PublishTrimmed>true</PublishTrimmed>
</PropertyGroup>
</Project>

Though if your app or library uses reflection in any sort of way, you need to let the tool-chain know that you do not want certain assemblies trimmed (because dotnet is good, but its not THAT good). You would do this by adding a block of XML like the following to your csproj file.

<ItemGroup>
<TrimmerRootAssembly Include="System.Data.SqlClient" />
</ItemGroup>

Publish as Single File

Another new option that comes with dotnet core 3.0 is the ability to publish your entire application as a single assembly (exe/dll).

To do this, you will need to the option to your csproj file.

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netcoreapp3.0</TargetFramework>
<PublishSingleFile>true</PublishSingleFile>
</PropertyGroup>
</Project>

This can be combined with PublishTrimmed to produce a very small assemby that contains your application and the required assemblies required to execute the application in a single exe/dll without having to ship the entire dotnet core 3.0 runtime.

Publish as Ready to Run (AOT)

ReadyToRun is by far the most exciting new option made available in dotnet core 3.0. This isnt simply JITing the MSIL, this is a genuine compilation of as much MSIL to native binary as possible. This is an incredible optimisation if you plan to publish packages on a per-platform basis. This is all as simple as adding the option to your csproj file.

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netcoreapp3.0</TargetFramework>
<PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>
</Project>

If you do have any assemblies that you would like to remain as MSIL in your project for whatever reason (incompatabilities or if the R2R compiler fails) you can exclude any assemblies with the following

<ItemGroup>
<PublishReadyToRunExclude Include="AssemblyToExclude.dll" />
</ItemGroup>

Combined

For the best results, it is possible to combine all these options

<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netcoreapp3.0</TargetFramework>
<PublishTrimmed>true</PublishTrimmed>
<PublishSingleFile>true</PublishSingleFile>
<PublishReadyToRun>true</PublishReadyToRun>
</PropertyGroup>
</Project>

Adding appsettings.json options to a dotnet core console application

Sun, 17 Nov 2019 10:08:04 +0000

Something that annoyingly does not come as standard in the dotnet core console application template, and, it is not documented anywhere with Microsoft is: appsettings.json. This comes as standard with ASP.NET Core applications, but no other applications, and the thing is, it is very simple to add to any dotnet core application.

The first thing you will need to do is add the following nuget packages (at least) to your application:

Microsoft.Extensions.Configuration
Microsoft.Extensions.Configuration.FileExtensions
Microsoft.Extensions.Configuration.Json

Once you have those packages installed, you can then add a new json file to the route of the project named “appsettings.json”. When you have added the new json file, right click on it in the solution explorer, click properties, and in the properties panel, change the “copy to output directory” option to “copy if newer”.

Once you have the basics done, we can move on to the code:

Your Program.cs file should now look something like this:

static void Main(string[] args)
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(
"appsettings.json",
optional: true,
reloadOnChange: true
)
.Build();
}

The “optional: true” makes the appsettings.json file completely optional, if the file does not exist, the Build() will not throw an exception, and the “reloadOnChange: true” option will cause the config to be updated automatically when the json file is changed.

It is as simple as that, as I said before, I don’t know why this is not part of the default template.

Microservices Introduction

Tue, 12 Nov 2019 20:42:47 +0000

Everybody has heard of the term “microservice”, but not many people know what they are, how they work, or how to implement one. Many people think they are a complex system that needs a lot of complex setup and management. In fact, they are a very easy way to remove heavy lifting from your web frontend to a more appropriate place.

When developing a piece of web software with microservices doing some of the heavy processing, all you need is:

Message Queue/Bus
1 (or more) VM’s (to install and run your service)
1 (or more) Web Frontend

The most basic way to explain what happens is:

The web frontend serialises a model, and posts that model as a message to the queue
A service installed on one or more VM’s listens to the queue
A service will pick up the message from the queue, and:
1. Deserialise it, and process it. or,
2. Deserialise it, not be able to process it, and place it back into the queue

And that is it.

If there is more than one service, they will all be able to monitor the queue, but only one will process one message, but if there are 100s of messages, your 3 or 4 services, will process those in parallel (4 services processing a message each, rather than 1 service processing 1 at a time).

As in the example above, this architecture can have different services listening to the same queue for different messages and performing different heavy duty tasks. Or simply decoupling certain critical tasks from the web frontend.

In the next post, I will show you how to create this architecture using Windows Azure, C# and dotnet core.

Who should we blame?

Wed, 18 Jan 2017 14:33:10 +0000

Something that we all know is that there is a blame culture in business. Something that not many people know is that we don’t need a blame culture in business.

Take this scenario:

Worker A is tasked with Job A to be performed weekly
Worker B is tasked with Job B to be performed daily
One day, Worker B is away, and Job B needs to be performed
Worker A is asked to perform Job B by Manager C
Worker A has no previous knowledge of Job B, but is competent, so performs Job B

Now in this scenario, we have a competent worker who has been asked to do something they are not used to doing, and because it is a daily process, it is time critical that it is done that day.

An amount of days go by and worker B returns and continues performing Job B, only to find that a small, yet critical step has been missed by Worker A meaning that Job B has not been performed correctly.

Who is to blame:

Worker B for not properly documenting the processes of Job B?
Worker A for not properly following the existing documentation of Job B?
Worker A for not properly performing Job B?
Manager C for practices that mean only Worker B is qualified to perform Job B?
Manager C for asking Worker A who has no knowledge of Job B to perform Job B?

The answer? Nobody. None of these people should be blamed for any of these reasons because the culture of blame is not productive.

What should happen after this issue is.

Worker B confers with Worker A to find out exactly what problem this has caused, if any. Worker B should then create a solution and display its validity to Manager C. The solution should then be deployed. After this, Worker B should then update or create the documentation to Job B, and if possible, restructure Job B in a way where the issue is no longer possible. This will allow any future worker will be able to perform Job B without this issue arising again.

What happened here is, the company did not waste time finding out who was the root cause of the issue, they wisely spend money finding out what was the root cause of the issue and ensured that it could no longer happen.

Knowing who caused the problem does not fix the problem and it does not save you any money, as a business, knowing who caused a problem, costs you money.

The Battle for Proper Working Hours

Mon, 09 Jan 2017 22:42:10 +0000

For many developers, the normal 9 - 5 shift does not really apply. Development is a creative job, and you cannot force more creativity from more hours.

For many developers, the normal 9 - 5 shift does not really apply. Development is a creative job, and you cannot force more creativity from more hours. Management seldom understand this and it can be difficult to articulate the point to a non-technically-minded or non-creative-minded manager. Management are usually not open to offering flexible work time too, and if they are, it is usually within very rigid parameters: “Must be in 9:00 - 17:00, or 8:30 - 16:30”, which is not very flexible.

Real flexibility comes in when you are given an amount of work to complete, and a deadline to complete it by. The amount of hours you work to achieve that deadline is irrelevant. While this is the complete opposite end of the scale to rigidly set, long hours, it is how intelligent, salaried, well behaved employees should be treated by any goal oriented company (results rather than throughput).

As for the hours, management cannot expect to force extra creativity from an employee that has used up their creativity for the day, for whatever reason it has been used up. If i was to come into the office and spend 2 solid hours coming up with the best work of my life, a manager would expect me to continue down that road for another 6 hours, but I, and many others know, it is not physically or mentally possible. It is exhausting while it is happening, but, that vein of gold is there for the taking, once the vein is used up, its gone.

Therefore the concept of 40 hours, or 37.5 hours or even 35 hours does not work, especially in the tech industry in the modern era. I, and many other developers, can get a job specified as a 5 day job, done in 2 days if we were capable as humans to do this, but, the job takes 5, or 6 or 8 days, because it is not possible to ever work at 100% capacity, never mind for any amount of time.

My employer recently reduced our working hours from 40 to 37.5 and set non-carry-over flexitime in place (with core hours of 10:00 - 15:00, for the convenience of scheduling meetings) (so, not flexitime, but, less rigid), but had to throw in the quip “but i will still be doing 60 hour weeks”, which seemed to be a jab at the “lazy employees” getting their way. The problem is, he might be at work for 60 hours, but he sure is not working for 60 hours.

Why is it such a battle to get employers and management to realise, if you want more from your employees, have them at work less, and have them working more.

The Pain of Developing a Xamarin App for OSX and iOS

Mon, 09 Jan 2017 23:00:00 +0100

When developing applications for Windows, even Windows 10 or some flavour of Linux or BSD, you pretty much have free reign over what you want to do. When it comes to Android, iOS and Mac OSX, it is a different story.

Well not exactly with OSX, that is more of a recent addition (restriction) in Sierra.

I have spent the last five weeks bootstrapping and building a client application using xamarin on Mac OSX. I chose to use El Capitan, as that was what I could get to run on the hackintosh.

Everything was running well until today, when we had a new starter who came in with a brand-new MacBook running Sierra. We set up the build environment, we set up the extras that were required, built the solution and everything was fine.

Until, we tried to run the application that had been built from the solution. First, there was an immediate crash when the application attempted to load System.Reflection.Emit.DynamicMethod, which didn’t exist on the platform, even though it did. It turns out that even though the file exists, it is not compatible with the new security settings in Sierra. There is a way to disable the use of dynamic code generation, which is to tell Ninject (our DI library) to use reflection, rather than code generation.

Once we got past this, we then got an almost immediate crash while attempting to load System.Reflection.Emit.ILGenerator, which given that we are using reflection, not code generation, we should not be loading any code generation libraries at all. But the main Ninject library references them and requires them.

In the midst of this, another team began prototyping an iOS app with xamarin, and ran into a very similar issue, though this was easily solved with setting ninject to use reflection.

With the OSX app, the solution ended up being, switching from the Xamarin.Mac Mobile framework, to the Xamarin.Mac .NET 4.5 framework, which then allowed for much more compatibility with ninject and some of our other libraries.

It turns out, the route cause of all of this, is the operating system’s kernel. Neither like code generation, and iOS outright bans it. I couldn’t tell you why Seirra does not like code generation, but it does not.

Lesson learned: use the full framework with the largest feature set, rather than the minimal framework with the reduced feature set for negligible performance gains. Computers are fast, very fast, these days… No need to skimp.

739s

Tue, 01 May 2012 20:00:00 +0100

733s

Wed, 25 Apr 2012 20:00:00 +0100

725s

Mon, 15 Aug 2011 23:00:00 +0100

624s

Tue, 30 Nov 2010 23:00:00 +0100

629s

Tue, 30 Nov 2010 23:00:00 +0100

The Angry Dev

Windows 10 Is Dying, but Gaming (and working) on Linux Is Easy

Why Linux Is Perfect for Gaming and Work in 2025

Step 1: Install Ubuntu

Step 2: Keep Ubuntu Updated (No Command Line Needed)

Step 3: Install Steam on Linux for Gaming

Step 4: Use Heroic Games Launcher for Epic Games and GOG Titles

Step 5: Install Google Chrome on Ubuntu

Step 6: Use LibreOffice for Work (or Install It If Missing)

Step 7: Add Essential Apps for Everyday Use

Step 8: Enjoy Your New Linux Setup

Why Event Driven Systems Are Not That Hard

Publishing and Handling Events Isn’t Hard

Distributed Messaging Made Easy with MassTransit

Reliability Isn’t Hard: Use the Outbox Pattern

Observability Isn’t Hard with OpenTelemetry

Schema Contracts Aren’t Hard with AsyncAPI

Debugging Isn’t Hard with Event Stores

Summary

How to Upgrade Windows 10 to Windows 11 on Unsupported Hardware (Step-by-Step with Rufus)

Before You Start: Important Note

What You Need to Upgrade to Windows 11 with Rufus

Step 1: Download Rufus and the Windows 11 ISO

Step 2: Create a Bootable Windows 11 USB with Rufus

Step 3: Upgrade from Windows 10 to Windows 11

Step 4: Enjoy Windows 11 on Unsupported PCs

A few things to remember:

Final Thoughts

Why UUIDs Beat Integers as Primary Keys (And Why Performance Isn’t the Issue)

What’s a UUID, Really?

Why Developers Like UUIDs

1. Generate Anywhere

2. Merge Without Collisions

3. Safer URLs

The Performance Myth

Things to Watch Out For

Rule of Thumb for Developers

Benchmark: INT vs UUID in PostgreSQL

Query Performance

Index Size

Takeaway for Developers

TL;DR

The Lie You Are Being Told About AI and Junior Developers

The Uncomfortable Truth: AI Needs a Pilot

The C# Mistake You're Probably Making with Memory

The Role of the Garbage Collector

The Power of the using Statement

Best Practices for Resource Management

Don't Buffer, Stream! How IAsyncEnumerable Solves API Performance Issues

What is IAsyncEnumerable<T>?

Why Use IAsyncEnumerable<T>?

How to Implement It

Important Considerations

Conclusion

Most Unit Tests Are a Waste of Time, but You Need to Write Them Anyway

Why Most Unit Tests Feel Pointless

Example:

But Here’s Why You Still Need Them

Tests Define Behavior

Tests Enable Refactoring

Tests Catch Edge Cases You’ll Forget

What to Write Instead of Meaningless Tests

1. Test Real Business Logic

2. Use In-Memory Dependencies Instead of Mocks

3. Favor Integration Tests for Controllers

So What’s the Right Balance?

Final Thoughts: Write Less, Test Smarter

Snap Unsnapped: Why Ubuntu's Packaging Isn't the Universal Dream You Were Promised

The Walled Garden: Isolation to a Fault

Resource Hog: High RAM and Disk Space Usage

Outdated and Insecure: Version Disparity and Security Risks

The Ecosystem Conundrum: Canonical’s Control

Conclusion: A Promising Idea with Implementation Flaws

Why Leetcode Style Interview Tests Are Bullshit

You Clearly Cheated?! (I didn’t)

The Darker Side of Tech Layoffs (it's darker than it seems)

The Weight of More with Less: The Burden on Remaining Employees

The Golden Handcuffs Tighten: The Frustration of Those Seeking New Opportunities

The Downward Pressure on Salaries: A Threat to Earning Potential

The Vicious Cycle: Redundancies Fuelling More Burnout

Benchmark: `INT` vs `UUID` in PostgreSQL

The Power of the `using` Statement

What is `IAsyncEnumerable<T>`?

Why Use `IAsyncEnumerable<T>`?