Gluing things together

Gluing things together

One of the most important things in coding is how to hold it together. In this short article I will share some thoughts on callbacks, events, observables, promises and tasks. This is what I have experienced in my time programming and I would be glad if you could share if you don't agree with me on something.

Why callbacks are bad

When I started programming some years ago I started with C# and Javascript. While .NET already had the Event in Javascript callbacks were everywhere. Then the word "callback hell" was coined.
In short callbacks and also Events for that matter are bad because they defere the code execution to some other place which can be hard to find especially when you are following from one callback to the next for multiple steps. Therefore it pollutes the code and can separate concern which should not be separated.

Why callbacks can be good

Defered execution is not always bad. To create modulation and structure callbacks and events are a major tool I have used. They should not pollute the local code and if there is a sign that a module is internally hold together by events or callbacks it is most likely better to create an abstraction layer. It is possible that callbacks and events are used in a local module but it should not be domain code.

Event based programming with RxJs

Event based programming with RxJs is another approach to events. Or should I say its exactly the same approach except for the fancy api's RxJs provides to you. It also provides that many tools that it makes a lot of sense to use it for domain code in a local module. As it is a new model for code continuation it can be a bit confusing at first when you do not know the api in the beginning but once you know it it provides you an abundance of tools for code flow control.

Promises And Tasks

The Promise type from Javascript and the Task type from .NET have runtime support and some syntax sugar to it which means they can provide you with yet another set of tools like threading and async execution. They are backed deep into the language and are used everywhere as control mechanisms. They aren't specifically for flow control or domain code.

Always those blockages

Now sometimes what I wrote above doesn't hold true. There are always special cases which change the whole perspective. Just before I said I prefer a callback over a Task because I didn't like the sight of three lines versus one just for flow control. Maybe I already feel different when I look the next time at it.

Comments

Post a Comment

Popular posts from this blog

Components of Tasks & Threading in .NET

Image
I recommend understanding the basics of async and await before you read this article. This is a good introduction from Stephen Cleary. As you might know simply using async and await doesn't mean your code is executed on different threads. To achieve this you must use Task.Run , TaskFactory.StartNew or the Task Parallel Library . This is an introduction in the different components at play when you want to schedule tasks on different threads. TaskFactory The TaskFactory is a simple container where you can configure options for the creation and continuation of Tasks. Furthermore you can specify an canncelation Token which will be used by all Tasks created through this factory. And lastly you can define your own TaskScheduler. It's your choise if you want to use a TaskFactory to start a new task or if you want to start a task directly trough Task.Run. MSDN TaskFactory TaskScheduler The TaskScheduler is responsible to run the next task on the correct
Read more

Debugging information and visual studio

Image
Without debugging information there is no debugging. By default debugging information is included when you build your project with the Debug configuration. Configuring debug information When you create a new project with .NET , Visual Studio provides two default build configurations in your project. Debug and Release . A solution build configration defines which projects are built and deployed for which target platform ( x86 , x64 or Any CPU ) although the platform can be overwritten by the project build configuration. The solution file ( .sln ) holds the values you configured. A project build configuration can define anything you can configure in the project file ( .csproj ). But they are mainly used to configure the target platform, if the output should include debugging information and if the complier should optimize the code. When debugging information is included the default ( Portable for .NET Core and Pdb-only for .NET ) is that a seperate symbol file is beeing create
Read more

Creating a cordova plugin and using it with ionic

In this article I will show how you can create a cordova plugin and use it in an ionic project. Prerequisites Before you can start you need to install the following tools. Node 6 LTS NPM 3+ Creating a cordova plugin Initialising the plugin To create the project files for the cordova plugin you can use use plugman which is a nice cli. I was using version 2.0.0. > npm install -g plugman ... > plugman --version 2.0.0 > plugman create ^     --name PingPong ^     --plugin_id cordova-plugin-pingpong ^     --plugin_version 0.0.1 > cd .\PingPong `plugman create` will create the following file/folder structure. PingPong   src                             <- Folder for native code   www                          <- Folder for JavaScript API which calls native code     PingPong.js                          <- Public API    plugin.xml                 <- Plugin configuration file The next step is to add the platforms y
Read more