Interview on InternetException

Solid

Wed, 26 Oct 2022 14:14:41 +0200

The single-responsibility principle - piece of software should have only one responsibility
The open–closed principle - things should be open for extension but closed for modification
The Liskov substitution principle - changing interface implementation should not brake software
The interface segregation principle - it is better to have more specialized interfaces than single big one
The dependency inversion principle - dependencies should be abstracted via interfaces

Further read:

https://en.wikipedia.org/wiki/SOLID

.NET/C# interview questions

Wed, 26 Oct 2022 10:21:52 +0200

Equals and GetHashCode

Tue, 25 Oct 2022 16:36:49 +0200

Custom implementation is usually only necessary if default, reference equality is not enough. In example:

entities value based equality
value equality of deserialized objects
custom comparisons based on other criterias

public class ImaginaryNumber : IEquatable<ImaginaryNumber>
{
 public double RealNumber { get; set; }
 public double ImaginaryUnit { get; set; }

 public override bool Equals(object obj)
 {
 return Equals(obj as ImaginaryNumber);
 }

 public bool Equals(ImaginaryNumber other)
 {
 return other != null &&
 RealNumber == other.RealNumber &&
 ImaginaryUnit == other.ImaginaryUnit;
 }

 public override int GetHashCode()
 {
 return HashCode.Combine(RealNumber, ImaginaryUnit);
 }
}

Difference between Controller and ControllerBase

Tue, 25 Oct 2022 16:28:23 +0200

Controller type inherits from ControllerBase and have Views support
ControllerBase type is better suited for APIs

Further read:

https://learn.microsoft.com/en-us/aspnet/core/web-api/?view=aspnetcore-6.0

Kestrel

Tue, 25 Oct 2022 15:56:40 +0200

default application server for .net
cross platform
best performance and memory utilization
may not have some advanced features of HTTP.sys on Windows
may be used with proxy server or as internet facing server

Further read:

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/servers/kestrel?view=aspnetcore-6.0

ASP.NET Core controller level exception handling

Tue, 25 Oct 2022 15:53:52 +0200

To handle exceptions on Controller/Action level Exception Filters are used.

[TypeFilter(typeof(SampleExceptionFilter))]
public class ExceptionController : Controller

Exception Filters are implemented using IExceptionFilter with OnExcetion method override to handle exceptions.

Exception Filters can be applied to Controller and Action level.

Further read:

https://learn.microsoft.com/en-us/aspnet/core/mvc/controllers/filters?view=aspnetcore-7.0#exception-filters

https://learn.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.mvc.filters.iexceptionfilter?view=aspnetcore-7.0

ASP.NET Core global exception handling

Tue, 25 Oct 2022 15:49:53 +0200

To add global exception handling in ASP.NET Core just use configuration method:

app.UseExceptionHandler

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/error-handling?view=aspnetcore-6.0#exception-handler-lambda

What ASP.NET Middleware can do?

Tue, 25 Oct 2022 15:45:12 +0200

Pretty much everything. Default ASP.NET Core request handling pipeline is consisting of bunch of middlewares:

Whole list of built-in middlewares can be found here:

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-7.0#built-in-middleware

There is possibility to write custom middleware too.

Middleware in OWIN

Tue, 25 Oct 2022 15:40:45 +0200

There are 2 ways of writing OWIN middleware in ASP.NET Core.

Pure OWIN - usefull if you want to integrate with OWIN compatible module but not written in C#
ASP.NET Core OWIN middleware

ASP.NET Core Middleware:

This type of middleware can be:

delegate of Func<HttpContext, Func<Task>, Task>
class with IMiddleware imlementation

app.Use(async (context, next) =>
{
 // Do work that can write to the Response.
 await next.Invoke();
 // Do logging or other work that doesn't write to the Response.
});

Pure OWIN Middleware:

This rather would be used to integrate with OWIN middlewares written in different language, so that ASP.NET Core implementation directly is not possible.

Owin model and Kestrell request handling

Mon, 24 Oct 2022 15:23:02 +0200

OWIN - Open Web Interface for .NET
allows web apps to be decoupled from web servers
defines standard way for middleware to be used in a pipeline to handle requests and provide responses
ASP.NET Core applications can interoperate with OWIN-based applications, servers and middleware

Microsoft.AspNetCore.Owin package provides two adapter implementations:

ASP.NET Core to OWIN
OWIN to ASP.NET Core

This allows ASP.NET Core to be hosted on top of an OWIN compatible server/host or for other OWIN compatible components to be run on top of ASP.NET Core.

Expression Trees

Mon, 24 Oct 2022 15:08:43 +0200

’tree like’ data structure
each node is expression (method call, equality comparison, binary operation etc.) representing a piece of code
you can compile expression tree and run code it represent
enables dynamic code generation at runtime
LINQ queries on DBs are implemented with Expression Trees
used in the dynamic language runtime (DLR)
anonymous lambda expression can be converted to ExpressionTree via compiler (i.e. x => x*2 can be represented as tree instead of delegate or anonymous lambda function)

Further read:

Linq

Mon, 24 Oct 2022 15:05:47 +0200

consistent model for working with data from various kinds of sources and formats (XML, SQL, ADO.NET, Datasets, .NET collections etc)
3 stages of working with LINQ:
- obtain data source
- create the query
- execute the query
data sources implements IEnumerable<> and are called queryable types
IQueryable<> interface inherits from IEnumerable<>
generally it is better to use LINQ via IQueryable<> which produces deferred query instead of producing result immediately
queries can be executed multiple times
queries can be forced immediate execution via Count(), Max(), ToList() or ToArray() etc.
LINQ to DB libraries (like EntityFramework) usually are implemented via Expression Trees

Entity Framework: Change Tracking

Mon, 24 Oct 2022 15:02:09 +0200

tracked entities are saved during SaveChanges() call
entities being tracked when they are:
- returned from DB
- attached to context
- added as subentity
tracking can be disabled (AsNoTracking() i.e.)

Further read:

https://learn.microsoft.com/en-us/ef/core/change-tracking/

Entity Framework: eager and lazy loading

Mon, 24 Oct 2022 14:57:56 +0200

lazy loading:
- delaying load of data until we specifically request for it
- i.e. accessing customer.Address loads Address of a customer in the background via separate SQL query
- property needs to be public, virtual
- context.Configuration.ProxyCreationEnabled should be true
- context.Configuration.LazyLoadingEnabled should be true
- to disable lazy loading completely Context.Configuration.LazyLoadingEnabled = false;
eager loading
- opposite of lazy loading
- loads related entities as part of the query
- done via .Include() query

Further read:

Pattern matching

Mon, 24 Oct 2022 14:50:08 +0200

Pattern matching is used for:

testing expression to check if some value have certain characteristics
safer compare because ‘==’ and ‘!=’ can be overloaded

Examples:

a is int number

sequence is IList<T> list

switch statement:

command switch
{
 Operation.SystemTest => RunDiagnostics(),
 Operation.Start => StartSystem(),
 Operation.Stop => StopSystem(),
 Operation.Reset => ResetToReady(),
 _ => throw new ArgumentException("Invalid enum value for command", nameof(command)),
};

switch with ranges:

tempInFahrenheit switch
{
 (> 32) and (< 212) => "liquid",
 < 32 => "solid",
 > 212 => "gas",
 32 => "solid/liquid transition",
 212 => "liquid / gas transition",
};

collection pattern matching:

array is [1,1,2,3,5,8, ..]

Further read:

https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/functional/pattern-matching

Reflection

Wed, 19 Oct 2022 16:44:33 +0200

obtain information about types and members at runtime
create instances, invoke or access them
dynamic code generation

Further read:

https://learn.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/reflection

Deployment models

Wed, 19 Oct 2022 16:42:01 +0200

Type	Command
framework-dependent executable for the current platform.	`dotnet publish`
framework-dependent executable for a specific platform.	`dotnet publish -r <RID> --self-contained false`
framework-dependent binary.	`dotnet publish`
self-contained executable.	`dotnet publish -r <RID>`

Further read:

https://learn.microsoft.com/en-us/dotnet/core/deploying/#publish-framework-dependent

.NET AOT

Wed, 19 Oct 2022 16:39:08 +0200

Ahead of the time compilation to machine code

produces self-contained application which:
- starts quicker
- uses less memory
- does not require .NET runtime installed
it is better for workloads with high deployment instances (clouds)
makes runtime code generation impossible
not all libraries are compatible

Further read:

https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/

.NET Jit

Wed, 19 Oct 2022 16:36:28 +0200

Just - in - time compiler.

part of CLR
for all .net programs for all .net languages
converts MSIL to native machine code
compiles code when it is necessary at runtime
also it is possible to pre-compile to native code at compile time instead

Further read:

https://www.geeksforgeeks.org/what-is-just-in-time-jit-compiler-in-dot-net/

Records

Wed, 19 Oct 2022 16:33:51 +0200

can be class or struct
creates methods overrides for enforcing value equality instead of reference equality:
- Object.Equals
- Object.GetHashCode
- operators
  - ==
  - !=
implements IEquatable<> parameter
implements ToString
supports deconstruction
supports with expression
meant to be immutable

Positional records is a more concise syntax for record:

primary constructor parameters match the positional parameters of the record declaration
public init-only properties for each parameter

Further read:

https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/records#characteristics-of-records

Is it possible to block GC?

Wed, 19 Oct 2022 16:28:54 +0200

We can.

for some critical part of application code using GC.TryStartNoGCRegion method.
using CER (Constrained Execution Regions) (obsolete)
with GC LatencyModes

Further read:

https://learn.microsoft.com/en-us/dotnet/api/system.gc.trystartnogcregion?redirectedfrom=MSDN&view=net-7.0#overloads

https://learn.microsoft.com/en-us/dotnet/framework/performance/constrained-execution-regions?redirectedfrom=MSDN

https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/latency

Garbage Collector

Wed, 19 Oct 2022 16:26:09 +0200

automatic memory management
allocates and releases memory
prevents memory leaks and accessing dead objects
provides memory safety
virtual memory space
defragments/compacts memory
heap have 3 generations
- 0 - for new objects;
- 1 - for objects that lives through GC from 0
- 2 - for long living objects from 1 and 0
also Large Objects Heap (LOH) for big objects like arrays over 85,000 bytes

Further read:

https://learn.microsoft.com/en-us/dotnet/standard/garbage-collection/fundamentals?source=recommendations

Covariance and Contravariance

Wed, 19 Oct 2022 16:21:04 +0200

enables implicit reference conversions for
- arrays
- delegates
- generic type arguments
Covariance preserves assignment compatibility
Contravariance reverses assignment compatibility
allows for matching signatures of delegates and method groups
- to assign to delegates from method that returns more derived types - covariance
- to assign to delegates from method that returns less derived types - contravariance
Covariance and Contravariance are supported in Generics for implicit conversions for type parameters
- allows method to have more derived return type than defined by generic type parameter of the interface
- this allows implicit conversions from one generic interface to another (from IEnumerable<string> to IEnumerable<object> even if first does not inherits from second)
- allows generic types to have less derived argument types than specified by the generic parameter of the interface (implementation of IEqualityComparer<BaseClass> can be implicitly converted to IEqualityComparer<DerivedClass> because IEqualityComparer.Equals is contravariant)
- implicit conversions works for interfaces but not classes that implement from those interfaces (i.e. this won’t work List<Object> list = new List<String>())

Assignment compatibility is when object of a more derived type is assigned to an object of a less derived type.

.NET Generics

Wed, 19 Oct 2022 15:48:04 +0200

Allow for:

generalization of logic based on available types
specify possible supported types
re-usability of code
type safety
defers the exact specification of logic until the class or method is declared and instantiated by user code with all type parameters specified
mostly used for collections (some non-generic versions of collection are not recommended like ArrayList i.e.)
information of exact type parameters used in a generic can be obtained at runtime by reflection

Further read:

Data structures in .NET

Wed, 19 Oct 2022 14:52:50 +0200

In table below official recommendations for choosing data structure for your needs:

Generic	Non-Generic	Thread safe	Purpose
`Dictionary`	`Hashtable`	`ConcurrentDictionary`	key value pairs, lookup
`List`	`Array`	`ImmutableList`	access items by index
`Queue`	-	`ConcurrentQueue`	FIFO queue
`Stack`	-	`ConcurrentStack`	LIFO queue
`LinkedList`	-	-	access items sequentially
`ObservableCollection`	-	-	notfications after modification
`SortedList`		`ImmutableSortedSet`	auto sorted collection
`HashSet`		`ImmutableHashSet`	dictionary of just keys (high performance set operations)

Further read:

Strings in .NET

Wed, 19 Oct 2022 14:44:37 +0200

sequential collection of chars
immutable
max 2GB or about 1 billion characters
reference type
are interned - CLR saves memory by maintaining a table, called the “intern pool”, that contains a single reference to each unique literal string declared or created programmatically in your program.

Further read:

https://learn.microsoft.com/en-us/dotnet/api/system.string?view=net-7.0

https://learn.microsoft.com/en-us/dotnet/api/system.string.intern?view=net-6.0#remarks

What type can not be object field?

Wed, 19 Oct 2022 14:33:00 +0200

ref struct type can not be used as object field.

Further read:

`ref struct` types

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/ref-struct

`ref struct` types

Wed, 19 Oct 2022 14:28:48 +0200

added as part of C# 7.2.
defined with ref struct StructName
always on the stack
never part of heap
cannot be element of an array
cannot be field type of reference type
can’t implement interfaces
can’t be boxed
can’t be type argument
can’t be captured by closure of lambda or local function
can’t be used in async methods
can’t be used in iterators

Further read:

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/ref-struct

Value types as fields in objects

Wed, 19 Oct 2022 14:26:29 +0200

Value types are stored in the heap when they are part of the reference type.

Reference types vs Value types

Wed, 19 Oct 2022 14:17:17 +0200

Reference types:

passed via reference
reside on the heap
subject to GC
inherits from System.Object

Value types:

passed via value
reside on the stack, CPU registers or the heap
no subject to GC
inherits from System.ValueType

Further read:

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/reference-types

https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types

https://www.infoworld.com/article/3043992/a-deep-dive-value-and-reference-types-in-net.html

.NET Type System

Wed, 19 Oct 2022 13:59:44 +0200

shared type system across all .net languages
primitives data types library
5 kind of types:
- classes
- structures
- enumerations
- interfaces
- delegates

Further read:

https://learn.microsoft.com/en-us/dotnet/standard/base-types/common-type-system

ThreadPool

Wed, 19 Oct 2022 13:53:37 +0200

provides a pool of threads
can be used to execute tasks
post work items
process asynchronous I/O
process timers

Further read:

https://learn.microsoft.com/en-us/dotnet/api/system.threading.threadpool?view=net-6.0

Task Parallel Library (TPL)

Wed, 19 Oct 2022 13:51:20 +0200

simplify process of adding parallelism and concurrency to application
scales concurrency automatically
data parallelism
task based async programming
data flow

Further read:

https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-parallel-library-tpl

Locking with integer

Wed, 19 Oct 2022 13:44:02 +0200

In short:

it will not work because it requires boxing and boxing will create new object for reference in lock every time code is executed so lock statement will not prevent anything.

Further read:

https://intellitect.com/blog/locking-a-block-of-code-with-an-integer/

Locking in .NET

Wed, 19 Oct 2022 13:27:01 +0200

lock statement blocks execution of a code block for single thread that hold lock
the same thread can acquire and release lock again
any other thread is blocked from the statement
lock on dedicated instance only
using the same instance on multiple lock statements may lead to deadlock
avoid using as lock
- this, as it might be used by the callers as a lock
- Type instances, as those might be obtained by the typeof operator or reflection
- string instances, including string literals, as those might be interned
Hold a lock for as short time as possible to reduce lock contention.

Below code block is translated by compiler

Thread vs task in . NET

Wed, 19 Oct 2022 13:12:33 +0200

task is asynchronous operation
thread is abstraction on OS thread

Further read:

https://www.c-sharpcorner.com/article/task-and-thread-in-c-sharp/

What is SynchronizationContext in .NET

Wed, 19 Oct 2022 13:08:18 +0200

multi threaded programs usually uses one of the threads as means of synchronization
there are message loops to pass unit of works (like Windows message queue)
message queues require messages formats and convention for handling it
single thread to handle ASP.NET request is waste of the resources (before .NET 2)
thread pool was better but inconvenient to work with
instead SynchronizationContext queues work for given context not thread
thread have current context
context does not have to be unique but can be shared between multiple threads
thread can change context but this is rare
SynchronizationContext keeps count of all asynchronous operations
Windows Forms uses WindowsFormsSynchronizationContext
WPF and Silverlight uses DispatcherSynchronizationContext
Console app and WindowsServices and ThreadPool threads uses default SynchronizationContext
ASP.NET uses AspNetSynchronizationContext

Further read:

Does async/await creates new thread?

Wed, 19 Oct 2022 12:58:00 +0200

In short: no.

Longer explanation:

task that want to do I/O write call to driver write
driver operations are performed asynchronously
write operations on devices is done without CPU involved
finish of writing is done via interrupt
interrupt, schedules Deferred Procedure Call
DPC schedules Asynchronous Procedure Call
APC notifies thread that I/O write is done
task that was doing I/O is scheduled with continuation of its method after I/O is done.
some threads might need to be borrowed for handling APC and such but no thread is spawn to handle I/O

I recommend reading this post: https://blog.stephencleary.com/2013/11/there-is-no-thread.html . This will explain the topic much better than I can.

Avoid deadlock with asynchronous methods

Wed, 19 Oct 2022 12:52:45 +0200

avoid doing AsyncOperation.Result
parent method waits for Result while child method waits for parent thread to take control, after being done with async I/O
both waits
deadlock

Further read:

https://medium.com/rubrikkgroup/understanding-async-avoiding-deadlocks-e41f8f2c6f5d

https://stackoverflow.com/questions/15021304/an-async-await-example-that-causes-a-deadlock

Asynchronous programming in .NET

Wed, 19 Oct 2022 09:52:30 +0200

Asynchronous programming patterns in .NET:

Asynchronous Programming Model (BeginOperation/EndOperation)
Event-based Asynchronous Pattern (invoke event with result from async job)
Task-based Asynchronous Pattern (Task<>)

Ways of achieving asynchronous code in .NET

async, await
Task class API (Run, WhenAll, WhenAny, etc.)
ThreadPool.QueueUserWorkItem(ThreadProc);

Further read:

async/await in .NET

https://learn.microsoft.com/en-us/dotnet/standard/asynchronous-programming-patterns/

async/await in C#

Wed, 19 Oct 2022 09:51:34 +0200

async/await syntax should be used for I/O bound asynchronous operations only.

public async Task<int> GetUrlContentLengthAsync()
{
 var client = new HttpClient();

 Task<string> getStringTask =
 client.GetStringAsync("https://docs.microsoft.com/dotnet");

 DoIndependentWork();

 string contents = await getStringTask;

 return contents.Length;
}

Compiler transforms code into a state machine that to track yielding execution for await and resuming execution when a background job is finished.

Things to keep in mind:

async method needs await
add Async suffix to asynchronous methods
async void for ‘Fire and Forget’ work i.e. event Handlers
be aware of mixing LINQ with async lambdas
wait for tasks in a non-blocking manner (do not use Task.Result i.e.)
for tight loops use ValueTasks
Consider using ConfigureAwait(false) for performance and for avoiding deadlocks

Further read:

CPU bound vs I/O bound

Wed, 19 Oct 2022 09:35:37 +0200

There are two types of asynchronous operations in .NET.

I/O bound
CPU bound

For I/O bound async/await syntax should be used. TPL should not be used for this. async methods does not spawns new thread to hand le I/O work asynchronously.

For CPU bound operations TPL should be used (Task.Run). This spawns new thread. Performance testing should be done to check if overhead of new thread and context switching is not greater than actual work to be done.

SupressFinalize in IDisposable interface

Tue, 18 Oct 2022 14:24:06 +0200

informs GC that object does not need to be added to finalizer queue
finalizer execution is not deterministic and objects can live for long time in queue - this is optimization technique
to make sure that object disposes of any unamanaged resources even if Dispose will be not called we need to implement finalizer

Basically finalizer execution time is not deterministic. We cannot predict when this will be called and till that time - object is existing and still taking memory space. Since we are controlling creation and disposal of those resources we can say to GC: ‘Do not worry about that! It already had been taken care of!’. So this way object will be destroyed sooner, leaving this space to be used by something else possibly.

IDisposable interface pattern

Tue, 18 Oct 2022 14:16:21 +0200

Example implementation of IDisposable

public class MyResource : IDisposable
{
 public MyResource(IntPtr handle)
 {
 this.handle = handle;
 }

 public void Dispose()
 {
 Dispose(disposing: true);
 GC.SuppressFinalize(this);
 }

 protected virtual void Dispose(bool disposing)
 {
 if(!this.disposed)
 {
 if(disposing)
 {
 component.Dispose();
 }

 CloseHandle(handle);
 handle = IntPtr.Zero;
 disposed = true;
 }
 }

 ~MyResource()
 {
 Dispose(disposing: false);
 }
}

MyResource object have pointer which is unmanaged. This is why this class should implement IDisposable interface. Implementation should be correct according to recommended pattern (see below for documentation).

There a re few points to highlight here:

General Interview Questions

Tue, 18 Oct 2022 13:32:58 +0200

Closed
Open - to consider for yourself
- Interesting technical problem you solved lately
- Interesting technical problem you solved during your career
- What is the process of the MR/PR change review for you
- What is great success you accomplished lately? What skill did you improved lately?
- What is your greatest failure during your career? What was your biggest mistake?

What is DDD

Tue, 18 Oct 2022 13:29:02 +0200

software design approach
software should be driven by business domain
pieces of software should match the business domain
goals:
- domain is primary focus
- complex design should base on model of the domain
- devs and business should continuously work on refining this model to address changes in business
common language for defining a business model of the domain
complex logic should be abstracted to domain

Further read:

https://en.wikipedia.org/wiki/Domain-driven_design

What is BDD

Tue, 18 Oct 2022 13:24:32 +0200

based on TDD
better collaboration between devs, QAs and business than TDD
behavioral tests first, implementation second
behavioral tests should be easy to understand, simple
those tests should be written in specific language, possible to understood by business
combines idea of unit tests naming, acceptance tests standard agile framework (As a XXX I want YY to achieve ZZ), and acceptance criteria with Gherkin

Further read:

https://en.wikipedia.org/wiki/Behavior-driven_development

What is TDD

Tue, 18 Oct 2022 13:08:00 +0200

Test-driven development

software requirements are converted to tests cases *before* actual implementation
implementation is done against all those test cases
opposing to first writing an implementation then tests cases

Further read:

https://en.wikipedia.org/wiki/Test-driven_development

What is asynchronous programming?

Mon, 17 Oct 2022 16:25:05 +0200

software often waits for some I/O operation to complete (file operation, network call, database query etc.)
we can use this time for something productive instead to wait for data to be available or I/O operation to be completed
with asynchronous programming user can work in the meantime
not waiting for I/O operations synchronously enhances user experience

Of course this problem is much more complex. Modern software operates on much more different PC architecture than 20 years ago. Nowadays software must be asynchronous to appear more user friendly and to made better use of modern multi CPU architecture. Right now complex, professional software uses multiple processes, threads on multiple CPUs (CPU you buy is not really *single* CPU) or even utilize GPU for more complex computations (like i.e. video editing software). Before that we mostly had single threaded desktop applications that had ‘please wait’ or ’loading’ pop ups. Right now this is song of the past really and to achieve better User Interfaces that allow to edit tag of your post without changing whole post. With mobile devices on the rise and sometimes lousy cellular network those kind of designs would not be sensible or sometimes impossible to implement. Did you ever happened to reenter some chunk of data into some software because you lost it? Maybe network was down? Or you hit back button by mistake? Right now it belongs to past mostly. All of those would be hard to do with synchronous operations. Right now people are bit spoiled and they tend to leave the page/application if it appears to be slow and not every company can sell ‘one-in-the-market-necessary-for-your-work-software’ that you will be forced to use. And this is why we have asynchronous operations and this is why we have asynchronous programming model that allows us to program such operations.