DEV Community: Edwin Klesman

Choosing the Right ASP.NET Core API Approach: Minimal or Controller?

Edwin Klesman — Wed, 04 Oct 2023 12:19:23 +0000

As a .NET developer, you are no stranger to building web applications using ASP.NET Core. With the introduction of ASP.NET Core 6, Microsoft has provided developers with two distinct approaches to building APIs: Minimal APIs and Controller APIs. In this article, we will explore both types, understand their pros and cons, and discuss scenarios where you might choose one over the other.

ASP.NET Core Minimal API

Minimal APIs are a lightweight and streamlined way to build web APIs in ASP.NET Core. They are designed to make API development faster and more concise.
Minimal APIs allow you to define routes and handle requests using a single file, often referred to as a “Program.cs” file.

As Microsoft describes them:

The design of minimal APIs hides the host class by default and focuses on configuration and extensibility via extension methods that take functions as lambda expressions.

Let’s dive into an example of building a Minimal API.

Minimal API Implementation Example

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.MapGet("/hello", () => "Hello, Minimal API!");

app.MapPost("/greet", async (HttpContext context) =>
{
    using var reader = new StreamReader(context.Request.Body);
    var requestContent = await reader.ReadToEndAsync();
    return $"Received POST request with content: {requestContent}";
});

app.Run();

It is pretty straight forward, right? Using the MapGet function, we have defined a function that handles the GET request to the “/hello” endpoint, which gives back a string.
Using the MapPost function, we’ve added a POST request handler for the “/greet” endpoint, which reads the request body and returns a response with the body of the request added to it.

Pros

Minimal Boilerplate: Minimal APIs require less code and fewer files compared to traditional controller-based APIs. This can lead to quicker development and easier maintenance.
Faster Startup: Due to their lightweight nature, Minimal APIs have faster startup times, making them suitable for microservices and serverless architectures.
Functional Approach: Minimal APIs embrace a functional approach, allowing developers to define routes and handlers using a more functional and expressive syntax.

Cons

Limited Features: Minimal APIs may not offer as many built-in features and conventions as Controller APIs. You might need to implement certain functionality manually.

Useful Resources

Check out these resources to read more about Minimal APIs for your ASP.NET Core project:

ASP.NET Core Controller API

Controller APIs are the traditional approach to building APIs in ASP.NET Core. They rely on controllers, which are classes responsible for handling HTTP requests and returning responses. Controllers give a more structured way of implementing your API, but also require more understanding of how to set them up properly.
As Microsoft describes them:

Controllers are classes that can take dependencies via constructor injection or property injection, and generally follow object-oriented patterns.

Let’s look at a simple example showing a controller-based implementation.

Controller API Implementation Example

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

[Route("api/[controller]")]
[ApiController]
public class GreetingController : ControllerBase
{
    private readonly ILogger<GreetingController> _logger;

    public GreetingController(ILogger<GreetingController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IActionResult Get()
    {
        return Ok("Hello, Controller API!");
    }

    [HttpPost]
    public IActionResult Post([FromBody] string content)
    {
        if (string.IsNullOrEmpty(content))
        {
            return BadRequest("Request content cannot be empty.");
        }

        // Process the content as needed
        _logger.LogInformation($"Received POST request with content: {content}");

        return Ok($"Received POST request with content: {content}");
    }
}

In this example, I’ve mimicked the implementation of the Minimal API code example. I’ve added simple functionality to the POST handler function, to check if the content is empty, and which writes logging.
I wanted to show you the logger as with a controller class, it is easy to use dependency injection to add dependant functionality in its constructor, which can be used to quickly expand the API controller’s functionality. In this example, it was done for logging.

Pros

Rich Features: Controller APIs offer a wide range of features, such as model binding, validation, action filters, and routing attributes. These features can be especially helpful in complex applications.
Convention Over Configuration: Controller APIs follow a convention-based approach, reducing the need for explicit configuration. This can lead to a more structured and organized codebase.
Ecosystem Support: Controller APIs have been around for a while, which means there are extensive resources, libraries, and community support available.

Cons

Boilerplate Code: Building Controller APIs often involves writing more code and creating additional files, which can slow down development.
Slower Startup: Controller APIs may have slightly longer startup times compared to Minimal APIs, making them less suitable for scenarios requiring rapid scaling.

Useful Resources

Check out these resources to read more about implementing Controller APIs for your ASP.NET Core project:

When to Choose Minimal API vs. Controller API

Now that we understand the characteristics of both types, let’s discuss when to choose each variant.
But before I dive into reasons to choose between the one or another, I’d love to emphasize that you are allowed and can implement both ways in your solution. For instance, when you have a full-blown function API for a web application, and you want to expand the API by adding a basically smaller subset of functionality (i.e.: for internal use in your company), ASP.NET Core allows you to mingle both.
Make sure these kinds of decisions are clear when you are working with a team of developers, so everyone understands why you’ve chosen the Minimal-, Controller-, or a combination of both API implementations.

Reasons to favour Minimal API

You need a quick and lightweight solution for a simple API or microservice.
Fast startup times are critical for your application.
You prefer a functional and minimalistic coding style.
You want to reduce boilerplate code and keep your codebase concise.

Choose Controller API When

You are working on a complex API with advanced features like model validation and custom action filters.
Convention-based routing and extensive attribute support are beneficial for your project.
You have an existing codebase that follows the Controller API pattern.
You need the full feature set and ecosystem support provided by Controller APIs.

Conclusion

In the world of ASP.NET Core, the choice between Minimal APIs and Controller APIs boils down to the specific needs of your project. Minimal APIs offer speed and simplicity, while Controller APIs provide a robust and feature-rich environment. Consider your project requirements, development team’s familiarity, and long-term goals when making this decision.
To recap what we’ve discussed:

You’ve seen the definition and a code example of both a Minimal- and Controller-based API implementation
Minimal APIs are quick, lightweight, and minimalistic. Ideal for simple APIs and microservices
Controller APIs are feature-rich, convention-based, and suited for complex and/or more structured applications

In the end, both Minimal APIs and Controller APIs have their place in ASP.NET Core development, and the right choice depends on the unique demands of your project.

Let me know in the comments or hit that ♥️ if you liked my article. I'm curious what kind of API implementation you use most often and for what scenario.

Code Hard, Ship Harder

.NET Developers, increase your productivity when working with databases: LINQ Me Up - Convert SQL into LINQ Code, vice versa and create LINQ code from your data samples

Enhancing Your ASP.NET Core MVC Project: CDN vs. Libman for Client-side Library Integration

Edwin Klesman — Thu, 28 Sep 2023 08:34:35 +0000

Web development offers a plethora of libraries and resources to improve the functionality and aesthetics of your ASP.NET Core MVC project. When it comes to integrating external libraries, choosing between a Content Delivery Network (CDN) and Microsoft’s Libman can be a pivotal decision. In this blog post, we’ll explore these two approaches to library integration, examine their advantages and disadvantages, and later, we’ll illustrate both methods using the popular Font Awesome icon library.

CDN vs. Libman: Adding External Libraries to Your ASP.NET Core MVC Project

In the realm of web development, the inclusion of external libraries can significantly enhance your project. To better understand the choices available, let’s first explore the general principles of using a CDN and Microsoft’s Libman for library integration.

Where is NuGet?

“Why isn’t NuGet package installer mentioned”, you might ask. That’s basically because in this article, I’m focussed on client-side dependency management. Although NuGet can be used to install client-side frameworks, etc. it is primarily used for managing server-side dependencies, such as .NET libraries and packages. It’s a package manager for .NET projects.

Using a CDN (Content Delivery Network)

Before we dive into the pros and cons, it’s important to note that a Content Delivery Network (CDN) is a globally distributed network of servers that serve web content, including libraries and assets. This approach is often favoured for its simplicity and speed in delivering resources to your web application.

Pros:

Simplicity: Incorporating libraries through a CDN is straightforward and requires minimal configuration. You typically only need to include a single line of code in your HTML or layout file.
Instant Updates: Libraries hosted on CDNs are updated automatically, ensuring you have access to the latest features and bug fixes.
Reduced Hosting Load: CDNs handle the hosting and distribution of files, reducing the load on your server.

Cons:

External Dependency: Your application relies on an external service, making it susceptible to downtime or changes in the CDN’s availability.
Performance Concerns: External requests to the CDN may impact your site’s loading times, especially if the CDN experiences delays.

Using Microsoft’s Libman (Library Manager)

On the other hand, Microsoft’s Libman (Library Manager) provides a different approach to managing libraries in your ASP.NET Core MVC project. It offers local control and customization options, making it a versatile choice for web developers who seek greater control over their project’s dependencies.

Pros:

Offline Availability: Libman allows you to download and store libraries locally, ensuring your application remains functional even when the CDN is inaccessible.
Version Control: You can specify the library’s version, preventing unexpected issues caused by updates.
Security: Local management of libraries allows for code auditing and adherence to security standards.
Customization: Selectively include only the parts of the library that your project requires, reducing unnecessary bloat.

Cons:

Initial Setup Complexity: Configuring Libman may be more involved compared to the simplicity of CDN integration, especially for beginners.
Maintenance Responsibility: With Libman, you are responsible for keeping libraries up-to-date and managing dependencies.

Want to boost your .NET coding productivity? Check out www.linqmeup.com — the AI powered SQL vs LINQ code converter & generator

Illustrating with Font Awesome Integration

Now, let’s have a closer look at how you can integrate Font Awesome using both methods:

Step-by-Step: Adding Font Awesome via CDN

The CDN integration method is fairly straight forward, as you can see in the steps it takes to include Font Awesome:

Open your ASP.NET Core MVC project.
Navigate to your HTML or layout file.
Add the following line inside the <head> section:

Integrating Font Awesome in your ASP.NET Core project using CDN.

Save the file, and you’re done!

Of course, you’ll need to add the HTML into the views to actually use the library and display the icons, but the integration part is quite easy.

Step-by-Step: Adding Font Awesome using Libman

The integration part, when using Libman at itself, isn’t all that harder than the CDN variant:

Open your ASP.NET Core MVC project.
Right-click on the project in Solution Explorer and select “Add” > “Client-Side Library.”
Search for “font-awesome” and select the desired version.
Choose which files you want to include (e.g., CSS, fonts).
Click “Install,” and Libman will download and add the selected files to your project.

Although the integration steps are quite simple for both the CDN and Libman variants, the actual difference is both the strength and constraint of the Libman way:

after integrating, you’ll have zero dependency on other services (CDN’s)
you are responsible for using the right version, and updating the client-side library when the time comes

Conclusion

The choice between a CDN and Libman for library integration in your ASP.NET Core MVC project is a critical one, impacting performance, reliability, and maintenance.

CDNs offer simplicity and immediate updates, while Libman provides offline availability, version control, and enhanced security.

While we’ve used Font Awesome as an example, the principles discussed here apply to many external libraries you may incorporate into your web projects. As you embark on your web development journey, understanding these approaches will empower you to make informed decisions, ensuring your projects thrive in the dynamic realm of web development.

My personal take: If you’re solo and just starting out, are not working on a business-critical corporate solution, or are working on a Minimum Viable Product, don’t be scared to take advantage of the simplicity of using a CDN. Use Libman when you want to fixate things, don’t want all the CDN dependencies clogging up your loading speed, or need to have control for a production environment.

🙏🏻 Thanks for reading, and let me know if you liked this article, and I’m curious which approach you take and why, so don’t hesitate to share in the comments.

Method Syntax vs. Query Syntax in C# LINQ: Unveiling the Differences, Pros, and Cons

Edwin Klesman — Wed, 30 Aug 2023 17:49:47 +0000

In the world of C# programming, LINQ (Language Integrated Query) stands as a powerful tool that enables developers to seamlessly interact with various data sources using a consistent syntax. When diving into LINQ, developers often encounter two primary ways of expressing queries: Method Syntax and Query Syntax. Each of these approaches has its own set of advantages and trade-offs, catering to different coding styles and scenarios. In this blog post, we’ll explore the key differences, pros, and cons of using Method Syntax and Query Syntax in C# LINQ.

Method Syntax: Concise and Fluent

Method Syntax is characterized by its concise and fluent nature. It employs a sequence of chained methods to define a LINQ query. Each method performs a specific operation on the data source, and the output of one method serves as the input for the next. This method chaining is not only readable, but also allows developers to create complex queries in a linear fashion.

An example of Microsoft LINQ C# code using Method Syntax

Pros

Conciseness: Method Syntax is often considered more compact and succinct, making it suitable for scenarios where brevity is essential.
IntelliSense Support: Modern code editors provide excellent IntelliSense support, which assists developers in quickly discovering and selecting appropriate methods.
Performance: In certain cases, Method Syntax might offer better performance due to its streamlined execution pipeline.

Cons

Learning Curve: For newcomers to LINQ, Method Syntax might pose a steeper learning curve, as understanding the sequence of methods and their specific purposes requires some familiarity.
Readability for Complex Queries: While Method Syntax is great for simple and moderately complex queries, highly intricate queries can become hard to read and comprehend due to the dense method chaining.

Query Syntax: SQL-Like Clarity

Query Syntax, on the other hand, resembles SQL queries and provides a more declarative approach to constructing LINQ queries. It allows developers to express their intentions clearly, resembling a structured language for querying data.

An example of Microsoft LINQ C# code using Query Syntax

Pros

Familiarity: If you are accustomed to SQL, Query Syntax can be a natural choice, as it resembles SQL statements, making it easier for SQL developers to transition into LINQ.
Readability: For complex queries involving multiple joins, grouping, and aggregations, Query Syntax can be more readable and maintainable than its method-based counterpart.
Less Error-Prone: Query Syntax reduces the likelihood of certain errors, like missing or out-of-order method calls, that might occur in Method Syntax due to the chaining nature.

Cons

Limited Expressiveness: While Query Syntax is excellent for many scenarios, it might struggle to handle very complex queries as efficiently as Method Syntax due to its higher level of abstraction.
Verbose: Query Syntax can become verbose for simple queries, as it often requires more lines of code compared to the concise chain of methods used in Method Syntax.
Performance Overhead: In some cases, Query Syntax might introduce a bit of performance overhead due to the additional translation step required to convert the query into method calls.

Choosing the Right Syntax

The choice between Method Syntax and Query Syntax in C# LINQ ultimately depends on the context and the developer’s preference. Consider the following factors when making your decision:

Familiarity: If you have a strong background in SQL or prefer a more declarative approach, Query Syntax might be a more intuitive choice.
Readability: For complex queries involving multiple operations, Query Syntax could be more readable and easier to maintain.
Performance: If performance is a critical factor and you are comfortable with method chaining, Method Syntax might provide slight performance advantages in some cases.

In the end, the beauty of LINQ lies in its flexibility. You can even mix and match these two syntaxes within the same project, tailoring your approach to suit the specific requirements of each query.

As a sidenote: If you ever need a tool that saves you time by creating LINQ code from SQL or a data sample for you (it supports both Method- and Query Syntax), check out this online tool I created: linqmeup.com

Conclusion

Method Syntax and Query Syntax in C# LINQ offer developers two distinct avenues for expressing their data querying needs. Method Syntax boasts conciseness and fluency, while Query Syntax provides SQL-like clarity and familiarity.

As a famous (amongst others, for the extreme programming concept) developer once said:

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” — Martin Fowler

The choice between the two depends on factors like familiarity with SQL, the complexity of the query, and the desired level of performance. Whichever syntax you opt for, mastering both can provide you with a versatile set of tools to conquer diverse data manipulation tasks.

Let me know if you liked the article & please share in the comments what syntax version you prefer, and if this article helped you to decide between the two.

Code Hard, Ship Harder 🔥

How To Implement A "Maintenance Mode" in ASP.NET Core

Edwin Klesman — Fri, 07 Apr 2023 13:15:00 +0000

In this article, you will both learn how to put your asp.Net Core app into maintenance mode using the framework’s “App offline file” feature, and how to implement your own maintenance mode logic when you need more control.

Let’s start with the fast solution when you just need to put it in maintenance quickly.

Using the framework’s maintenance feature

For a fast implementation, you can use asp .Net Core’s maintenance feature by adding a file called “app_offline.htm” in the root of your solution. This is a very nice, quick and easy solution that lets you create a HTM(L) file with the layout and message that you want to show to your users you are performing maintenance on the app.

This feature is called the “App offline file”, and has some things to consider, like:

the file can be maximally 4Gb in size (should be more than enough)
it needs your app to receive another request to become online after removing the file
in specific situations, the app might not shut down immediately

You can read Microsoft’s documentation on the App Offline file feature, here: App Offline file - learn.microsoft.com

The App Offline file feature is very nice for small projects, MVP’s or demo setups, and side projects.

If you want more control of how to implement maintenance mode, and want to add logic- or signalling features for a more controlled process, you will need to code your own solution. I will explain this in the following part.

Rolling out your own maintenance mode feature

Creating your own feature has the advantage that you don’t rely on a file being put into place on the server, and you can implement all kinds of extra things, i.e.:

use application logic, a database value or a configuration file value to enable/disable maintenance mode (read on to see the configuration file implementation example)
you can log the timestamps to register when and how long maintenance mode was applied for reference
you could implement signalling logic like sending an email, SMS, etc. to service desk employees and/or other key users or people that need to know.

To implement your own maintenance mode in ASP .NET Core, you can follow these steps:

**Step 1. **Create a new middleware component that will intercept all requests to the application and return a “maintenance mode” page instead of processing the request. This middleware component should be registered in the request pipeline before any other middleware component.

Here’s an example implementation of a maintenance mode middleware component:

using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;

public class MaintenanceMiddleware
{
    private readonly RequestDelegate _next;

    public MaintenanceMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        // Check if maintenance mode is enabled
        if (IsMaintenanceModeEnabled())
        {
            await context.Response.WriteAsync("Maintenance mode is enabled. Please try again later.");
            return;
        }

        await _next(context);
    }

    private bool IsMaintenanceModeEnabled()
    {
        // Implement your own logic here to determine if maintenance mode is enabled
        return true; // Return true for demo purposes
    }
}

Step 2. In the Startup.cs file, add the maintenance mode middleware component to the request pipeline:

public void Configure(IApplicationBuilder app, IHostingEnvironment env) 
{ 
    // Other middleware components here... 

    app.UseMiddleware<MaintenanceMiddleware>(); 

    // Other middleware components here... 
}

Step 3. Implement the logic to enable and disable maintenance mode.

This could be done using a configuration file, a database, or any other means that suits your application.

Here’s an example implementation of a configuration-based maintenance mode toggle:

public static class MaintenanceMode 
{ 
    public static bool IsEnabled { get; set; } 
} 

public class Startup 
{ 
    public IConfiguration Configuration { get; } 

    public Startup(IConfiguration configuration) 
    { 
        Configuration = configuration; 
    } 

    public void ConfigureServices(IServiceCollection services) 
    { 
        // Other service configurations here... 

        // Add configuration-based maintenance mode toggle 
        services.Configure<MaintenanceModeOptions>(Configuration.GetSection("MaintenanceMode")); 
    } 

    public void Configure(IApplicationBuilder app, IHostingEnvironment env) 
    { 
        // Other middleware components here... 

        app.UseMiddleware<MaintenanceMiddleware>(); 

        // Other middleware components here... 
    } 
} 

public class MaintenanceModeOptions 
{ 
    public bool IsEnabled { get; set; } 
}

With these changes, you can now enable or disable maintenance mode by updating the configuration value for MaintenanceModeOptions.IsEnabled.

Configuration file example

Here’s an example of the appsettings.json configuration file that could be used to configure the maintenance mode toggle:

{ 
  "MaintenanceMode": { 
    "IsEnabled": false 
  } 
}

Concluding

Besides the technical implementation aspect — which I’ve shown you in this article — make sure to think about what option suits your development and deployment processes most.

Nowadays, techniques and tools are often used to minimize the pain of maintaining your application in production.
Things like DevOps, Continues Integration and Continues Deployment (CI/CD), deployment slots, and hot swappable environments have made a “maintenance mode” unnecessary in many scenarios, but not all.

And that, dear reader, is all I’ve got for you on maintenance mode for Asp .Net Core.

Hopefully this article gave you some food for thought, and a good starting point if you decide to apply a maintenance mode feature for your solution.

Code hard, Ship harder 🔥

Do you work on .Net solutions with lots of SQL / LINQ and do want to save time by converting SQL into LINQ code or the other way around? *Check out LINQ Me Up — Convert SQL queries into LINQ code and vice versa using AI*

A list of AI powered tools for C# Developers

Edwin Klesman — Wed, 08 Mar 2023 22:08:52 +0000

Since ChatGPT kicked everyone into an AI era of sorts, I thought it would be nice to sum up some AI-powered developer tools that are around today (2023) for C# developers.

Introduction

Developer tools that are using AI today, have one of

make a developer more productive by speeding up repetitive tasks
act as a second pair of eyes
helps developers by logically appending to our minds objectively
skips Google, shows instant personalized examples

Don’t worry, it will still take quite some time before an AI can replace our craftsmanship.
In the meanwhile, I’d love to show you some AI tools that are around in 2023, and get your feedback on this trend. Let me know in the comments if you’re using any of these tools, and if you think of this as useful additions or not.

Without further ado, here is my list.

AI Powered Developer Tools

IntelliCode: Developed by Microsoft, IntelliCode is an AI-powered extension for Visual Studio that provides intelligent code completion suggestions. IntelliCode provides AI-assisted code completion suggestions, which can help C# developers write code faster and with fewer errors. It can also detect code smells and suggest refactoring options, making it a valuable tool for code maintenance.
Pricing:
It is available for free in the Visual Studio Marketplace
Where to find it:
here’s the link to the marketplace page
DeepCode
DeepCode uses AI to analyze C# code and identify potential bugs and vulnerabilities. It can also suggest code improvements and highlight areas of the code that could benefit from refactoring.
Pricing:
It offers a free plan as well as paid plans with additional features. More information can be found on the official website.
Where to find it:
DeepCode: Semantic static code analysis for better software — powered by AI
Codota
Developed by Codota Inc., Codota is an AI-powered autocomplete tool that suggests code snippets based on the context of your code. It can help C# developers write code faster and with fewer errors by offering suggestions based on similar code found in millions of repositories.More information can be found on the official website.
Pricing:
It offers a free plan as well as paid plans with additional features.
Where to find it:
AI Assistant for software developers | Tabnine
TabNine
While this used to be a separate company, TabNine was acquired by Codota back in 2020. TabNine has similar features to Codota, but one recently announced cool feature that this tool has is generating unit tests using AI, which can really help to create some basic testing stuff for your application.
Pricing:
It offers a free plan as well as paid plans with additional features.
Where to find it:
AI Assistant for software developers | Tabnine
CodeRush
Developed by DevExpress, CodeRush is a productivity plugin for Visual Studio that uses AI to help you write code faster. It provides a variety of AI-assisted coding tools, including code generation, intelligent navigation, and refactorings. It can help C# developers write code faster and with fewer errors, as well as maintain existing code more easily.
Pricing:
It offers a 30-day free trial and a variety of pricing options for both individuals and teams.
Where to find it:
CodeRush: Free IDE Productivity Extension for Visual Studio | DevExpress
GitHub Copilot
Developed by GitHub and OpenAI, GitHub Copilot is an AI-powered code completion tool that uses GPT (Generative Pre-trained Transformer) to suggest code snippets based on the context of the code. It can be integrated into Visual Studio Code and other popular code editors, and can help C# developers write code faster and with fewer errors. GitHub Copilot is available as a technical preview.
Pricing:
it’s still in preview and free.
Where to find it:
Generic info > GitHub Copilot · Your AI pair programmer, Visual Studio plugin > link to the marketplace page
LINQ Me Up:
With OpenAI’s release, a lot of tools are being created to harnass the power of AI. LINQ Me Up helps developers save time by converting SQL into LINQ code. This is useful to learn LINQ or to migrate projects to use the advantages of LINQ (easier to debug, compile-time checks, etc.).
Pricing:
You get free credits at registration. There’s the possibility to buy credits, or a $8 p/month subscription
Where to find it:
LINQ Me Up — Convert SQL queries into C# LINQ code using AI
disclaimer: I (the author) created this product

My take on AI-driven developer tools for C# developers

I’ve personally only recently used Copilot for a couple of quick tests, and started to use IntelliCode recently. Furthermore, I’ve created LINQ Me Up to convert some stuff at my own convenience, making it for others to enjoy the same speed for converting.

I believe that tools like this are good to save time by not having to write things from scratch over and over.
It speeds up the search process and saves time compared to Googling on ways to implement specific code parts.

That doesn’t take away that I still believe that we are at a young and fragile beginning stage of the wonders of AI.
Reviewing, testing and common sense are still needed before pushing code into production.

My take on this: any tool that can help you provide value towards others by letting you focus on value instead of syntax, is a good one.

What are your experiences / what is your stance on using AI tools?

Let me know what your take is on these tools, and what experience you’ve had (if any) with these tools.

In the meanwhile: Code Hard, Ship Harder 🔥

How To Convert a SQL Query Into C# LINQ

Edwin Klesman — Sun, 26 Feb 2023 21:51:07 +0000

In this article, I’ll show you what the basic steps are for converting a SQL query into LINQ. You’ll learn the basic steps needed while we convert an example query.

In this article, it's assumed that you have a basic understanding of SQL, and know how to write C# code.

Introduction

Structured Query Language (SQL) is a powerful language for working with relational databases. It is widely used to retrieve and manipulate data from a variety of databases. However, when it comes to working with data in C# code, Language Integrated Query (LINQ) is a popular alternative to SQL. In this article, we will show how to manually convert a SQL query into LINQ, step-by-step.

Example SQL Query

Let’s begin with an example SQL query that includes a join, a couple of where conditions, and ordering. Here is the query:

SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID
WHERE Orders.ShippedDate IS NULL AND Orders.Freight > 100
ORDER BY Orders.OrderDate DESC

Step-by-Step Conversion to LINQ

Let’s begin with the overall steps that you need to perform when converting your SQL into LINQ.

Step 1: Analyse The SQL Query

When you have selected the query you need to convert into LINQ, it makes sense that you at least understand how the SQL is put together.

I often do this — with SQL not written by me — by walking through the query from top to bottom and marking anything that’s unclear. I tend to use Visual Studio Code and SQL comments for this:

-- just writing a comment above the lines that are unclear

Then I’d look up / Google any functions or constructions that aren’t clear to me, so I can get a grasp of the functionality.

When I know what the query does functionally, I write down the query’s functionality in my own words. For example, for our example query the explanation would be:

The query retrieves the OrderID, CustomerName, and OrderDate from the Orders and Customers tables, where the ShippedDate is null and the Freight is greater than 100. The results are ordered by the OrderDate in descending order.
This results in a list of Orders from new to old, that haven’t been shipped yet and have a freight amount of at least 100.

Step 2: Using A Data Context Class

Depending on your needs, and what is already implemented in your solution, you might need to create a data context class. A data context class provides a connection to the database and maps database objects to C# classes.
A data context class can be created manually by you, or when you’re using Entity Framework (EF), you can generate a *data context class *using that.

Creating a data context class
Here is an example of a data context class coded as the representation of a database that our example query would use:

public class NorthwindDataContext : DbContext
{
    public DbSet<Order> Orders { get; set; }
    public DbSet<Customer> Customers { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=Northwind");
    }
}

This data context class represents a database called “Northwind” and includes two entities: Order and Customer (each entity is typically a table in your database). We also specify the connection string for the database.

Using Entity Framework (EF)
Here are the steps to use Entity Framework to generate a data context class and use it to query data with LINQ:

Install Entity Framework: If you haven’t already done so, install Entity Framework by adding the EntityFramework package to your project. You can do this by opening the NuGet Package Manager Console in Visual Studio and running the following command:
Install-Package EntityFramework
Create a data model: Create a class that represents your database schema, also known as a data model. You can create this class by using the Entity Framework Designer in Visual Studio OR by writing code manually. Here is an example of how to define a simple data model for a Northwind database:

    public class NorthwindDataContext : DbContext
    {
        public DbSet<Customer> Customers { get; set; }
        public DbSet<Order> Orders { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Customer>()
                .HasKey(c => c.CustomerID);

            modelBuilder.Entity<Order>()
                .HasKey(o => o.OrderID);

            modelBuilder.Entity<Order>()
                .HasRequired<Customer>(o => o.Customer)
                .WithMany(c => c.Orders)
                .HasForeignKey(o => o.CustomerID);
        }
    }

    public class Customer
    {
        public string CustomerID { get; set; }
        public string CompanyName { get; set; }
        public string ContactName { get; set; }
        public string ContactTitle { get; set; }
        public string Address { get; set; }
        public string City { get; set; }
        public string Region { get; set; }
        public string PostalCode { get; set; }
        public string Country { get; set; }
        public string Phone { get; set; }
        public string Fax { get; set; }

        public virtual ICollection<Order> Orders { get; set; }
    }

    public class Order
    {
        public int OrderID { get; set; }
        public string CustomerID { get; set; }
        public DateTime OrderDate { get; set; }
        public DateTime? ShippedDate { get; set; }
        public decimal Freight { get; set; }

        public virtual Customer Customer { get; set; }
    }

Step 3: Creating the LINQ code

To retrieve data with LINQ, we need to interact with the data context class, depending on the manual or EF flavor, there are minor differences in the code (which I’ll illustrate using comments).

So let’s use the DbSet property of the data context class. I usually go from top to bottom in the SQL query, and write down the equivalent in LINQ using auto-completion to find any options.

In our example, we want to retrieve the OrderID, CustomerName, and OrderDate from the Orders and Customers tables. We can do this with the following LINQ query:

using (var context = new NorthwindDataContext())
{
    var query = from order in context.Orders
                join customer in context.Customers on order.CustomerID equals customer.CustomerID
                where order.ShippedDate == null && order.Freight > 100
                orderby order.OrderDate descending
                select new { order.OrderID, customer.CustomerName, order.OrderDate };

    var result = query.ToList();
}

This LINQ query uses a join to combine the Orders and Customers tables. It includes two where conditions to filter the results and an orderby clause to order the results.
Finally, it selects the OrderID, CustomerName, and OrderDate into an anonymous type. All similar to our input query.

An advantage of using ORM features
One optimization that you can make when you’re using an ORM like Entity Framework, is that you can use so-called navigation properties, which saves you a “join” statement. For example:

var query = from order in context.Orders
            where order.ShippedDate == null
            select new 
            {
                order.OrderID,
                order.Customer.CustomerName,
                order.OrderDate
            };

In this LINQ query, we’re selecting the OrderID, CustomerName, and OrderDate properties from the Orders entity, using the Customer navigation property to get the associated CustomerName.

By using the navigation property instead of an explicit Join, the ORM can generate the appropriate SQL query behind the scenes, optimizing the query execution and simplifying the code for the developer.

Step 4: Compiling & Executing the LINQ query

With LINQ, the query is generated and setup, but only executed when you actually perform an action on it.

As visible in the LINQ example from step 3, the result variable will only get the information after a method like “ToList()” is performed on the LINQ query.

By setting a breakpoint on this line, you can compile and execute the query and check if this works properly.

Any typos or references to non-existing properties or entities should also have been long signalled by your IDE, as type-checking and compile time checks really form a nice way to filter out human mistakes.

Step 5: Validating the results

It is only common sense that, after you’ve setup your LINQ code AND verified that it compiles into proper code, you will test if the outcomes of the SQL and the LINQ are similar.

So step 5 is the testing phase, in which you typically could follow these steps to verify that your LINQ is giving the expected results:

Test step 1: Execute the SQL query: First, execute the SQL query in your database management tool, such as SQL Server Management Studio or MySQL Workbench. This will give you a result set that you can use for comparison.

Test step 2: Capture the SQL query: Next, capture the SQL query generated by LINQ. You can do this by inspecting the ToString() output of the LINQ query, as we did earlier:

var query = from order in context.Orders
            join customer in context.Customers on order.CustomerID equals customer.CustomerID
            where order.ShippedDate == null && order.Freight > 100
            orderby order.OrderDate descending
            select new { order.OrderID, customer.CustomerName, order.OrderDate };

string sql = query.ToString(); 
//This was ToList() before, but now results in a string 
//that you can get with a breakpoint on this line

Test step 3: Execute the LINQ query: Finally, execute the LINQ query and compare the result set to the one obtained from executing the SQL query. You can use a tool like LINQPad to execute the LINQ query and inspect the results.

using (var context = new NorthwindContext())
{
    var query = from order in context.Orders
                join customer in context.Customers on order.CustomerID equals customer.CustomerID
                where order.ShippedDate == null && order.Freight > 100
                orderby order.OrderDate descending
                select new { order.OrderID, customer.CustomerName, order.OrderDate };

    var result = query.ToList();

    // Compare the result set to the SQL query result set
    // ...
}

To compare the result sets, you can use a tool like Beyond Compare or WinMerge to compare the data in the two result sets. Alternatively, you can write a small program to iterate over the result sets and compare each row.

Keep in mind that there may be small differences in the ordering of the rows or the formatting of the data, so you may need to account for these differences when comparing the results. In addition, if you are using different database engines for the SQL query and the LINQ query, there may be differences in the way that data is stored and retrieved, so you should be aware of any such differences.

Overall, testing the SQL and LINQ output for equivalence is an important step in verifying the correctness of your LINQ queries, and can help you catch errors early in the development process.

Also, don’t forget to check if the query is at least equally fast to the original SQL version (although, in my experience, LINQ is often faster because LINQ generates better and faster queries with each new release).

That’s it! We have manually converted the SQL query into LINQ.

To conclude

In this article, we have shown how to manually convert a SQL query into LINQ.

We started with an example SQL query that included a join, a couple of where conditions, and ordering. We then demonstrated each step in the conversion process:

Step 1: analysing the SQL
Step 2: Using a data context class
Step 3: Creating the LINQ code
Step 4: Compiling & Executing the LINQ query
Step 5: Validating the results

From creating analysing the SQL, to creating a data context class to executing and testing the LINQ query, the entire procedure would take about 15 to 80 minutes, depending on your familiarity with LINQ and the complexity of the query.

If you’d ever need a faster way that would save you time to do this manually, check out an online tool that I created: LINQ Me Up. It is a conversion tool that empowers the power of AI to generate C# LINQ code from your SQL input in a minute (or a couple, depending on the size of your SQL query).

Thanks for reading my conversion guide, and I hope that it at minimum gave you some insights on how to go from SQL to C# LINQ.

Code hard. Ship harder 🔥

Unlocking the Potential of AI for Developers: How to Increase Productivity & Shorten Time-To-Market

Edwin Klesman — Fri, 13 Jan 2023 21:23:19 +0000

As technology continues to advance, Artificial Intelligence (AI) is becoming an increasingly important tool for developers. With the ability to act as a “Google on steroids,” an interactive context-sensitive search tool, and a digital assistant that takes care of repetitive and tedious tasks, AI has the potential to change the way we work and help us to create better and more efficient solutions. This post is a more in-depth article based on my Twitter Thread on AI for developers.

AI is starting to get valuable

Artificial intelligence (AI) is rapidly evolving and has the potential to change the way we work as developers. At its core, AI acts as a powerful tool that can help us to save time and effort while increasing productivity and shortening time-to-market.

One of the most significant advantages of AI is that it acts as a “Google on Steroids,” providing us with an interactive and context-sensitive search tool that can help us find the answers we need quickly and easily. Additionally, AI can act as a digital assistant that takes care of repetitive and tedious tasks, freeing up our time to focus on more important work.

As developers, it’s essential that we invest our time and effort in adding value to our projects. This means solving problems, weighing the current options, and giving our clients the right direction and implementation to get the most value out of their situation. By using AI, we can achieve this by increasing productivity, shortening time-to-market, and providing context-sensitive solutions.

While some developers may choose to write all the code themselves, or learn and find the best way and steps on their own, it will take more time, effort, and money than necessary. With all the online resources and AI added to that, developers can create products in a fraction of the time it would take otherwise.

In fact, quite a few developers in my network have used AI to create products in just a couple of days by coupling AI APIs on a website and adding payment functionality. These solutions are viable, used by many, and provide great value (even though they were implemented quickly).

It’s not magic (yet)

It’s important to note that while AI can help us to provide value, it cannot provide value by itself. The key is to use AI in the right way and to find out what value it can provide for you.

I personally have been playing with AI and I am currently working on a product powered by AI that helps developers transform SQL into LINQ C# code. The product is called **LINQ Me Up, **which you can checkout at https://www.linqmeup.com

AI in action for converting SQL into LINQ code: LINQ Me Up

Examples of how AI can aid developers

If you still can’t see how AI might benefit you as a maker, developer or digital entrepreneur, here are ten explicit examples of how AI could provide value:

AI can automate repetitive tasks such as code generation, testing and debugging, which can save developers a significant amount of time and increase productivity.
Natural language processing is one of the aspects that AI is increasingly getting better at, which can be integrated into chatbots and virtual assistants to handle customer service inquiries, freeing up developers’ time to focus on more important tasks.
AI can be used to optimize and automate the process of testing, which can shorten time-to-market by allowing developers to identify and fix bugs more quickly.
Analysing data and provide insights is another way in which AI can help developers to make more informed decisions, leading to more efficient and effective development.
Artificial Intelligence can improve the user experience of your product by providing personalized recommendations, which can help to increase engagement and retention.
AI can also be integrated into products such as website builders and e-commerce platforms, which can help to automate the process of creating and managing a website, saving developers time and effort.
AI can be integrated into code editors to provide developers with context-sensitive suggestions and auto-completion, which can improve code quality and reduce the time it takes to write code.
When it comes to the logistics angle of your project, AI can be of value also. AI can be integrated into project management tools to automate the process of task assignment and scheduling, which can improve team collaboration and productivity.
AI can be used to create predictive models that can anticipate and prevent problems before they occur, which can lead to improved product reliability and reduced downtime.
As video is getting more and more important in the online world of today, AI can also be used for image and video processing to automate tagging, captioning, and other tasks, which can save time and effort for developers working on multimedia projects.

To conclude

In conclusion, as developers, we should not ignore the potential of AI and should take the time to play around with it and find out what value it can provide for us.

Whether it’s as a tool that explains, writes, and creates, or as part of our solution to fulfil an otherwise complicated implementation, AI has the potential to change the way we work and help us to create better and more efficient solutions.

Take care and remember:

Create. Value. First.

This post is also published at Medium with more interesting articles of mine

To Learn Or To Ship, That's The Question

Edwin Klesman — Thu, 25 Mar 2021 12:06:14 +0000

Learning a framework or tool and shipping your product are two things that don't really mix up most of the time. In this article, I explain why you should separate the two for your project

Shipping Product 🚀

I have a strong belief that when your goal is to ship your MVP a la The Lean Startup, you need to use tools and techniques that you are familiar and comfortable with. That way, you can focus on creating the MVP and generating value.
The focus needs to be on the product level, meaning that everything you're doing is about thinking:

how will this add to the value creation for the end-users?
is this feature necessary, or can I do this in the next version?
does the feature feel natural, and is it easy to use for the users?
etc.

How you actually implement your project using (no-/low-)code, and if it is the neatest way to code it are not as important when you want to provide value without investing too much time and effort which results in a longer time-to-market.
Not when you're bootstrapping your product/service, and want to ship your product within a short timespan.

Learning The Tools 🎓

If you're working on a side project to learn a framework, stack, tool, whatever, it's best when you're not committing yourself to a stressful deadline. You can focus on learning the tools and choose simple tasks or projects to create so they can be realized within days or weeks.

Trying out variations and different approaches on how to create things with a framework really lets you get your hands in the code and often shows aspects and use-cases that are helpful later on.

Mixing Learning & Shipping

What you need to understand, is that when you're using tools/frameworks/.. for a product that you want to ship that you didn't use before, there is a great chance that this will stall your progress.

You'll most likely bump into an aspect that you want - ney..need (it's an MVP, right?) - to implement but then, when you're actually using it, you find yourself spending hours on figuring out how to get this small thing to work for your project.
Perhaps you even are the lucky one finding out there is a bug in that one feature that you need for your use-case that was going to save you a lot of time... 🙈

Nothing is more frustrating than finding yourself stuck or delayed because you assumed that a library would do the trick.
After developing for over 20 years I know that these scenarios are inevitable, but minimizing the risk of this happening and getting stuck less, can really mean the difference between "being in a happy flow working and getting enough progress to keep at it" and "getting stuck too many times and dwindling off to your next thing".

This is where the perseverance and consistency part for makers kicks in.

Investigate Upfront 🧐

In my experience, the only way to properly integrate something that's "new to you" in a product that needs shipping ASAP, is to find something upfront and research it before you start your product.
Researching means going over the website, Googling, and reading user scenarios on sites like Stack overflow. Finding out if the product is actually working and if there are people around that can help you.

Support & Community Matter 🤝

By making sure that the product is well supported and maintained you can be more assured that this will save you time, not cost you time.
Often, there are commercial products that will cost a little but that have proper support and guidance for your situation, which might give you more assurance that it will actually function.

When it comes to using open source, finding out if there is a vibrant community of users and demos for use cases or issue discussions can be a sign that it will help you out on creating and shipping your product.

Especially when you're implementing an edge-case that hasn't been implemented many times before, knowing that the creators, maintainers, or users of a framework or tool can help you out can be the life-changing fact you need.

Concluding 🏁

By now, I hope I've shown you why shipping and learning don't really blend well if you want to ship your MVP and get it out there using minimal effort on a strict deadline.

Here are the key take-aways I want you to remember:

Don't learn implementing something on the job if you want to ship your MVP anytime fast
Use frameworks, tools, and code that you are familiar with
If you need to use something for your project, research upfront if it has proven to be useful for your use-case and check if support and/or a vibrant community are around

Either code to learn or code to ship. Or first code to learn, then use what you've learned to use that in something to ship.

Working with the things you are familiar with really helps to keep the pace, focus on shaping the right product, and will reduce the number of times you will get stuck during the implementation phase.

And it will prevent me from having to tell you that wildly annoying but famous phrase:

👨🏻‍🏫 I told you so ☝🏻

Code Hard, Ship Harder 🔥

This article is also published on Medium

How to stop Laravel’s Valet asking for password

Edwin Klesman — Tue, 09 Feb 2021 10:45:35 +0000

If there is one aspect of Laravel that I like, it’s that it is accompanied by very nice tools.

Depending on how you like to develop you can even choose between different approaches and tools to develop with Laravel.

Valet is one of those tools. If you — like me — like to quickly setup your development environment, and test your work in progress asap, Valet helps you to setup test domains on your local machine very fast.

As Valet’s documentation explains:

Valet is a Laravel development environment for macOS minimalists. Laravel Valet configures your Mac to always run Nginx in the background when your machine starts. Then, using DnsMasq, Valet proxies all requests on the *.test domain to point to sites installed on your local machine.

What’s up with the password?

When you’ve developed in Laravel using Valet before, you will notice that once you reinstall Valet on a new machine (or clean install), it will start asking for a password.

After some research on Github, I found out why this is.
As it appears, there are two factors causing the continuous password prompt:

For security reasons, Valet prompts for the sudo password every time the command is used in a new terminal session
The code previously searched two files. The code that would create two files in /etc/sudoers.d was removed from the sourcecode

Since Valet uses sudo rights for some actions it needs to take, it depends on getting sudo rights to fully function.

How to prevent Valet from asking your password?

The answer is quite simple: you need Valet to trust your computer.

As you can find on the documentation page for Valet, the solution is revealed in the “other commands” section:

As the command states:

Add sudoers files for Brew and Valet to allow Valet commands to be run without prompting for your password.

Whereas the sudo command allows non-root users to run commands that would normally require super user privileges, the sudoers file instructs the system how to handle the sudo command (source: hostinger.com).

So, by using the “valet trust” command, you will indicate that the current machine can be trusted, which results in sudoers adjustments that will give Valet sudo permissions to operate correctly and without asking for your password each and every time.

To conclude

Please understand that the reason that you were prompted for the password in the first place, is because of increased security measures.

The security impact for using sudoers to give Valet sudo rights has also been discussed by the community on this Github thread concerning the issue.

Although using the trust command makes it easier to use valet without having to enter your password every time, always think about your machine setup, its connectivity to the internet and how this might affect your security at a realistic level.

Me personally, I’m happy to trust my device and am using Valet with a big smile once more.

Code Hard, Ship Harder 🔥

This article is also published on Medium

Makers: What vlog content would you like to see?

Edwin Klesman — Mon, 17 Aug 2020 13:50:17 +0000

Dear fellow coders and makers : I've posted a poll on twitter to find out what 🎬 vlog content is most appreciated/sought after.

Is it startup or developer stuff in general.
Vlogs about Xamarin mobile app dev?

Let me know by voting so I can get get more input:

My twitter poll

Sharing is ♥️ and will help me to get clearer insights! 🙌🏻

Exploring Your Mobile App Business Idea

Edwin Klesman — Fri, 26 Jun 2020 10:49:51 +0000

In this post, I give you actionable advice on what to think about and consider before you start building your mobile app business idea.

As a web- and mobile developer with over 16 years of experience on his belt, I’ve learned what needs consideration before you start your mobile adventure, both for business supporting apps and stand-alone mobile app services.

Every assumption that you’re starting your mobile app product on is false until proven valid

Your Assumptions Are Wrong

In an era where building Minimum Viable Products (MVPs), and pivoting ideas as taught by The Lean Startup and agile processes are king, assuming you just need to build your mobile app and turning it into a success is proven to have a 99% chance of failing.

Every assumption that you’re starting your mobile app product on is false until proven valid. This is a law that applies universally.

I’m not saying you’re always in the wrong ball-park. But it is unlikely that you are spot on in one stroke, and you should always assume that you are working on wrong assumptions.

Your assumptions could be a little off and just need a little tweaking to work for your idea, or they can be wrong entirely.

As an entrepreneur or maker, it is your job to find out what assumptions are right and wrong, and how to improve them or find the right ones for your product.

Here are some ways that can help you to minimize the error in your assumptions:

Scratch your itch: work on an idea for a solution that you need for yourself or to solve a problem that you’re experiencing yourself. That way, you can validate if it works for you. You’ll need to find out if there are enough of other people that have the same problem to see if this is going to be viable
Idea pivoting: create the simplest form of your idea that helps you to demonstrate your solution to others. This could be as simple as creating an Excel sheet, a clickable wireframe, mockups, or non-coding examples. If you’re a quick developer a simple duct tape proof of concept using your developer stack could do as well. Just invest the least amount of effort that is needed to enable the demonstration of your idea
Landing pages: you can pivot your idea on a simple website to show how and what value it provides (and for whom) to see if it gets tractions before you build anything.

There are awesome books available that can help to provide you with the right mindset and information to find out if your idea is viable.

Coming from a technical background, the following books helped me to shape my mindset for sure:

🔑 Take-aways:

You need to test your assumptions instead of being naive and think that you’re right
Get the right mindset by focussing on value
iterate on your idea by testing against potential users if it’s going to be viable. Create the simplest solution and use the agile circle of Think. Build. Learn. Adapt. Repeat.

Types Of Apps And Distribution Channels

One of the first questions I always ask is: does your app have to be in the app store?

Because of my software engineering background and diverse experience, I know there are many ways to build a solution. For apps, there are multiple form factors to implement them, like:

Native apps: iOS- and Android apps that are built using their native development tools
Cross-Platform apps: iOS- and Android mobile apps that are built with a single toolset, a shared logic implementation, and compiled into native variants
Hybrid apps: mobile apps that are built similar to cross-platform apps, but with the shared implementation and screens implemented using web technology. They are either “packed” into a native layer or compiled into native apps.
Progressive Web Apps (PWAs): these are apps that are built using web technology and that can be used in a mobile browser on smartphones. They can use a couple of mobile app features.
Mobile-friendly websites: these are websites that are accessible and user friendly when opened on a mobile device.

Besides considering the above implementation types, there are quite some channels that can be used to distribute your solution:

The app stores; a platform-specific channel that is integrated into the fibers of iOS and Android
Enterprise stores; you can create a private store for your company so employees (or customers) can use your apps in a “closed shopping” environment
Package distribution: For Android apps, you can distribute your app package (APK) via websites (or any other file sharing solution for that matter)
Websites: you can implement your solution as a mobile web app or mobile-friendly website and host it on a server somewhere.

Before you choose your solution and/or distribution channel, ask yourself this: Does the app need to be in the App Store?

In the past 10 years, I’ve noticed how a lot of companies and entrepreneurs wanted to “have their app in the AppStore” for the same reason that people used to want websites on the internet for their companies: they wanted to have a presence there.

Just having an app in the AppStore because you need to be present there doesn’t cut it anymore.

With the AppStore having over 2.2 million apps available, and 2.8 million apps being offered in the Google Playstore, you’re not going to get exposure — or actual users — unless your app provides value for its users.

Sure, the AppStore can be a commercially interesting distribution channel. But you’ll need to be featured and highly exposed to get the amount of traction to make things interesting.

If you’re building a mobile app or service targeted at consumers (B2C) You’ll are probably better off with releasing your mobile solution and communicating this through multiple channels and platforms instead of depending on the editorial teams at Apple and Google.

Commonly used (international) channels are used and for startups and/or independent solutions, early adopters are often targeted via Product Hunt, Hacker News, Reddit, etc.

Perhaps you should focus more on social media platforms and utilize focus features like groups on LinkedIn and Facebook.

Are you creating something that is going to be used internally? Use your main news-distribution channel and adjust process descriptions to get your app’s usage going.

Yes, the app stores are integrated highly into the OS, and linking and downloading the app is made easy. But “installing” your solution can also be done with Progressive Web Apps and their offline features or making it easy to save a link to your web app solution.

Don’t let your idea of what an App Store might bring you blind you from the alternatives. Instead, try to look at what mobile features are most useful and interesting for your solution, and find out if they provide enough value for the end-users before putting in a lot of effort or choosing directions.

🔑 Take-aways:

There are multiple ways to build an app. They all have their use-cases and pricing tag
There are multiple channels besides the app store that you can utilize to your advantage.
App stores sure have their pros, but they’re not holy. And they are already packed with millions of apps. Find out what channel will support your solution the most and always cross-check the effort needed to get your solution out there against the value that the channel might provide you

What Mobile Features Are Necessary?

A large part of choosing the right format for your solution depends on the features that your idea depends on.

ie: if you’re having a news related solution for a specific niche, you’ll probably want to trigger your users to open your app through push notifications on important news updates.

This is a feature* that is possible for native, cross-platform, hybrid, and progressive web apps.

*: I’m aware that desktop browsers have push notification functionalities, but they don’t work on mobile devices

If your solution needs to process the camera stream of a mobile device camera to recognize objects or apply filters, you’re going to be bound to native solutions or cross-platform/hybrid solutions (that are using frameworks that provide native support for those features).

A lot of companies are moving from native apps towards progressive web applications because they are easier to maintain, can be distributed faster, and are getting more and more feature support from both mobile- and desktop browsers.

You can look at the different types of mobile solutions as the layer of a union with the native apps being at its core and the other variants being wrapped around it.

The more your idea depends on the hardware features of mobile devices, the more likely you will be heading towards a native solution (the core of the union) or one of the surrounding layers.

🔑 Take-aways:

Double-check what mobile features you absolutely need for your minimal product definition and find out — together with a mobile expert if you’re lost — what fits your solution and what possibilities are available for your solution
If your implementation provides value to its users, the type of implementation will matter less, so focus on value creation and not app building

In the end, building apps isn’t about building apps: it’s about providing value that can be utilized in the palm of your hand.

Is Your Idea Viable On Mobile?

If you have a solution that requires users to fill in a lot of input fields, chances are that your solution isn’t cut out for mobile devices.

If things are so complex that they can’t be handled in a simple flow, chances are that you’re trying to combine multiple processes or services into one.

Mobile app usage is based on multi-frequent, short-used, and low barrier interactions with the mobile device. In other words: if you make it too complex, take to long or time dependant chances are that your solution isn’t ready for the small screens yet.

Try to find out what processes there are, which one results in the most value for its users, and you(r company) and focus on one of them.

You can see if there are processes that are dependant or highly related and choose to provide them together in a single app or you could see if a suite of multiple apps would be a better solution.

It all depends on what you’re trying to provide for your users, and only you can find out (preferably, together with your potential users) what makes sense and feels natural and logical.

Creating a simple, userfriendly mobile experience that will provide the user with value while not slowing them down or distracting them more than is necessary, can be tough.

Don’t underestimate the importance of making the solution ready for mobile.

In my experience, copy-pasting desktop experiences never work out and proof to be a waste of money and effort eventually.

“Simple can be harder than complex: You have to work hard to get your thinking clean to make it simple. But it’s worth it in the end because once you get there, you can move mountains.”

― Steve Jobs

🔑 Take-aways:

If things are looking too complex, find out of you’re trying to combine multiple things into one app
Make your solution usable in the context of mobile usage: multi-frequent, short-used, and low barrier interactions
Simple can be hard; find out how to improve the experience instead of saving effort and copy-pasting a desktop solution

Concluding

If you’ve come this far, you’ll have read about multiple aspects that you’ll need to consider when it comes to mobile solutions.

By focussing on the value that you want to provide to the app users and taking all the possibilities into account (instead of being blinded by the commonly known types of apps and distribution channels) I hope to give you the insights to make well-informed decisions.

Invest the minimal amount of effort necessary to test your solution and validate your assumptions using the feedback of your potential users.

In the end, building apps isn’t about building apps: it’s about providing value that can be utilized in the palm of your hand.

Code Hard, Ship Harder 🔥

This post is also published on Medium

Xamarin ios waiting for debugger to connect on port 10000 via usb

Edwin Klesman — Tue, 09 Jun 2020 10:57:58 +0000

This short post explains how to fix the “xamarin ios waiting for debugger to connect on port 10000 via usb” issue and get your debugger working again.

Xamarin ios waiting for debugger to connect on port 10000 via usb

On-device Debugging Wanted

Every mobile developer knows that you need to run and debug your app on an actual device to make sure that things are working as expected.

Wether it is the Anroid Emulator or the iOS simulator; they can only go so far on simulating the actual target environment of physical devices.

And when things DO go wrong (your solution rarely compiles and runs without any mistake) it really helps when you can debug on your device.

When you’ve grabbed your favorite drink and spun up the debug session, it can be extremely frustrating when the following happens with your Xamarin iOS project:

project building…. finished 😁
deploying to device …. 10..20..30………..100% 👌🏻
The top status bar is showing you the following message:

xamarin ios waiting for debugger to connect on port 10000 via usb
😅 okay, i’ll wait a few seconds
🥴
you wait for a minute… status remaining the same: it appears to be stuck

As it appears, the debugger can’t hook up with your iOS device, and won’t let you step through your code.

This bug seems to be occurring when you’re trying to debug via USB as well. Obviously, the error will then show up as follows:

**xamarin ios waiting for debugger to connect on port 10000 via wifi**

Meanwhile, on the device, you can use the app as expected but debugging is not possible.

Fixing the Infinite Wait

Somehow, this issue is caused by the build on the device not properly reacting to the message that Visual Studio is sending over on the default debugging port (which is port 10000).

The app lanches, but things are not communicating conform expectations of the debugging protocol.

In order to fix this from happening again, here are the basic steps that you should follow:

Remove the app from your iOS device
In Visual Studio For Mac go and clean your solution (Build > Clean All)
Right click on your iOS project and select “Reveal in Finder”, and delete the **bin* and *obj** directories
Close Visual Studio entirely
Restart your iOS device (it depends on your device how you need to do this, check Apple’s instructions if you don’t know how to do it)
While your phone is rebooting, you can spin up Visual Studio For Mac, open up your solution and rebuild your Xamarin.iOS project
As soon as your phone is ready and loaded, Build and Run your project on the device
This time, the deployed application instance should hook up nicely with Visual Studio for Mac once again
Debug and do your thing 🎉

Still Stuck?

The steps I mention in this post assume you’re running a project that is using the default debugging configuration for Xamarin.iOS projects.

If you’re still running into issues, check:

the debug settings on your project via: Right click on your iOS project > Options >iOS Debug. Enable debugging should be checked for your configuration (debug > iPhone)
check and see that you are actually trying to run the debug version (not the release)
check that the debug information is set to “Full” for your projecrt via: Right click on your iOS project > Options > Compiler

Photo by Glenn Carstens-Peters on Unsplash

The End

I hope these instructions saved you some time defeating the “Xamarin iOS waiting for debugger to connect on port 10000 via USB” message.

At least the origin for this bug (for once) isn’t because you:

a) set up something wrong or
b) put an awful and/or weird line of code in your project

These things tend to consume way too much time because we coders often tend to think it’s definitely a or b.

Don’t loose your spirits and keep up with building another awesome solution that provides value!

Code hard, Ship harder!

This post is also published on Medium