One web server for every home

Imagine having a affordable personal home web server, in your home, for half the price of an iPhone. Then imagine being able to create your own apps on this little gadget, that allows you to store your data privately within the comfort of your home, in addition to letting you access your apps from any device, from where ever you are in this world. Would that be of interest?

The reason why I am asking, is because this is actually my vision. My vision is to allow anyone to create any apps they want to, easily, without having to teach themselves difficult programming languages, and use these apps in such a way that they control and own the data themselves.

Everybody needs their own apps

Think about it for a moment. It doesn’t matter who you are, or what you do. Everybody needs a custom app, for some reasons. If you’re an ornithologist, you need to gather data about birds. To create an app that does such a thing, is actually quite easy. If you’re obsessed with music from the 80s, and are collecting vinyl albums, you’ll want to show off your record collection. Well, there’s not an app for that today. But creating one, is as simple as declaring a CRUD database table, and creating a GUI to create, read, update and delete records from the database.

The tail end of app development will never be solved by Silicon Valley. The reason is that there’s no money in solving it. When was the last time you saw a Silicon Valley company creating a product with a potential of maximum 1000 customers world wide?

By making it possible to create generic solutions, customisable by the end user, solving the tail end of software development is actually quite easy. And by creating it as a web app, and installing it on your own home server, it will feel almost exactly like any native app you can purchase through the app store. In addition to that it will work on all your devices, and not only your iPhone.

What software would you create if I told you that you could create your own app, and that it would take you no more than a couple of days, regardless of your existing knowledge and expertise?

Imagine 7.3 billion web servers

Imagine every single human on the planet having his or her own personal web server. What would be the effect of this? How would it change the world? How would it change science?

Today everyone with an internet connection can register at Facebook, and start writing whatever they want, and easily have it spread –Β Unless Marc Zuckerberg for some reasons doesn’t like what you write! The last point is crucial. Basically, Mr. Zuckerberg has very effectively positioned himself as the emperor of the entire world. Don’t believe me, realise he effectively controls “the word”.

In the beginning there was the word, the word was with God, the word was God! The Gospel according to John, chapter 1, verse 1.

Hence, arguably, Marc Zuckerberg is god! Is that a situation which we want? Do you think Marc will be a benevolent God? Even if he is benevolent, what about the other shareholders at Facebook …?

The only fix for this, is to give every single human being a personal home web server.

One year ago, I registered a company, with the sole purpose of delivering one web server, to every single human being on the planet. I have the operating system ready, I have all the software done – Now all I need is a huge HW company to help me create the hardware, or the ability to create my own hardware.

I have worked 10 years on these ideas. Do you believe I am crazy? Or do you believe I am brilliant?

If you’re interested in getting in contact with me, and discuss my ideas, feel free to use the form below …

HOWTO hire a million system developers

Developers are amazing. Most of them have this urge to share whatever they create with the rest of the world. Basically, to accomplish having a million developers working for you hence, is just to facilitate for an environment where sharing is so dead freakin’ simple, that it can be done, by simply clicking a button.

Phosphorus Five is that environment. If you don’t believe me, feel free to check out my previous blog. Pay especially attention to how I am able to create a reusable component out of a specialised solution, in no more than 5 seconds. This reusable component again, could easily be uploaded to some common “code sharing website”, which would allow its users to rapidly search for pre-fabricated components, solving their problems, whatever they are.

Basically, the end result being, that once Phosphorus Five acquires “tipping point”, one inevitable results will be, that you have millions of developers, sharing their components – Either for a small fee, or gratis, depending upon their own motives for sharing. Ending up with that you, have a million system developers, which you can use, to help you create your solution.

Then some words from our sponsors πŸ˜€

You just have to love this fella … πŸ˜‰

For the record, I once saw Steve Ballmer speaking in Oslo about 15 years ago. And it was just freakin’ amazing. Now imagine having a 100x as many developers working for you, as Microsoft, and Silicon Valley have combined. What would this do to you …?

Increase your software development productivity 100x

Get more work done, for less effort!

The above might sound like an exaggeration. However, it is not! Simply because in Phosphorus Five, you can reuse almost everything you do. In the video below, I am demonstrating reducing my projects from 388 LOC (Lines Of Code) to 1 LOC, by creating a reusable extension widget, from an existing web app page.

Basically, what this implies, is that you can reuse almost everything you do in one project, to the next. This suggests that if you’re creating more than one project, then every time you start out a new project, you’re almost done with it, before you even start!

You can find the code for this below the video. For the record, I had to slightly modify the code below, to avoid angle brackets, etc, since my blog can’t handle angle brackets in code segments, even if I HTML encode them manually … (Darn it WordPress!!)

Now before you check out the code, realise that we started out with a “page”. Then we turned that page into a reusable extension widget, in roughly 5 seconds. The end result, being a reusable component, we can reuse in other projects, or in other pages in the same solution. Please watch the video for an explanation of how we did this.

Features of our GitHub project browser

The video also demonstrates some other pretty nifty features. For instance, we are able to traverse any project from GitHub, without using any of the GitHub APIs. The way this works, is that we are able to treat HTML semantically, and extract parts of the HTML returned by GitHub, by transforming it into a lambda object, to retrieve its actual “data”. Basically, we’re “scraping” GitHub, and semantically extracting parts of their HTML, to semantically “understand” the structure of the project we’re browsing.

This allows us to treat HTML semantically, as “data”, and create an Ajax TreeView, which you can see either in the video above, or the screenshot below. The Ajax TreeView in our little “app”, is basically created by semantically “scrape” the GitHub project website, retrieving the data for the links to download its folders, and its files, allowing us to recursively traverse any GitHub project, by treating their HTML semantically.

In addition, we will automatically parse any Markdown files, and show them in HTML view, and show any code segments in a “syntax highlighter widget”. To do this, we first use the HTTP REST capabilities of P5, which allows us to download files, using any of the HTTP verbs, such as GET, POST, PUT, etc. Notice, this is done on the server. Then we inject the code into a “pre” HTML widget (code files), which is later highlighted using the highlight.js JavaScript library. The Markdown files, are first converted into markdown using the [markdown2html] Active Event from Phosphorus Five, for then to be injected as the content into a “div” widget.

To understand how we do this, take a look at the code at the bottom of this blog.

Our little code snippet, also shows how you can use the System42’s Ajax TreeView, in addition to creating a “datagrid” manually, by creating a table element, wrapping your “grid”. Below is a screenshot of our little app.

Below is the code we ended up with, after having created our extension widget. Evaluate the following code in your System42/Executor.

/*
 * Creates a GitHub folder browser, that will allow the user 
 * to browse and read all files within each folder of a project.
 * Will create one Ajax TreeView mirroring the folder structure of the project, 
 * semantically parsed from the HTML of the project's landing page, in addition
 * to a "datagrid" allowing the user to see all files within currently selected folder,
 * and view its content.
 */
create-event:sys42.samples.git-hub.file-browser
  return
    container
      oninit
        p5.web.include-css-file:"https://highlightjs.org/static/demo/styles/rainbow.css"
        p5.web.include-javascript-file:"https://highlightjs.org/static/highlight.site.pack.js"
      events

        /*
         * Downloads GitHub index page, and returns the URLs for both 
         * the child folders, and the Markdown files.
         * Expects [_arg] being URL of GitHub HTML page to download, and semantically parse.
         * Returns [.files] and [.folders] being collection of source files, 
         * and folders recursively inwards.
         */
        sys42.samples.git-hub._get-files-folders

          /*
           * Checking cache to see if requested folder has already been traversed, 
           * and exists in cache.
           */
          p5.web.cache.get:sys42.samples.git-hub.{0}
            :x:/../*/_arg?value
          if:x:/@p5.web.cache.get/*/*
            return:x:/@p5.web.cache.get/*/*/*

          /*
           * Buffers.
           */
          .folders-tmp
          .files-tmp
          .folders
          .files

          /*
           * Retrieving all "xxx.md" types of files, in addition to all folders.
           */
          p5.http.get:x:/../*/_arg?value
          p5.html.html2lambda:x:/-/**/content?value
          add:x:/@.files-tmp
            src:x:@"/@p5.html.html2lambda/**/svg/*/\@class/=octicon octicon-file-text/././+/**/a/*/\@href"
          add:x:/@.folders-tmp
            src:x:@"/@p5.html.html2lambda/**/svg/*/\@class/=octicon octicon-file-directory/././+/**/a/*/\@href"

          /*
           * Massaging results from above.
           */
          for-each:x:/@.folders-tmp/*
            split:x:/@_dp/#?value
              =:/
            add:x:/@.folders
              src:@"{0}:""{1}{2}"""
                :x:/@split/0/-?name
                :"https://github.com"
                :x:/@_dp/#?value
          for-each:x:/@.files-tmp/*
            split:x:/@_dp/#?value
              =:/
            add:x:/@.files
              src:@"{0}:""{1}{2}"""
                :x:/@split/0/-?name
                :"https://github.com"
                :x:/@_dp/#?value

          /*
           * Returning folders and files to caller, making sure we cache results first.
           */
          add:x:/../*/p5.web.cache.set/*/*/items
            src:x:/@.files|/@.folders
          p5.web.cache.set:sys42.samples.git-hub.{0}
            :x:/../*/_arg?value
            src
              items
          return:x:/@.files|/@.folders

        /*
         * Creates our TreeView bugger.
         * Expects [.folders] being initially treeview root items to create.
         * Will also create the default "files datagrid" after TreeView has been created.
         * Hence, also expects [.files], which it will pass into creation of "files datagrid".
         */
        sys42.samples.git-hub._create-tree-view

          /*
           * Deleting any previously created datagrids, if existing.
           */
          if
            fetch:x:/0/0?value
              widget-exists:git-hub-treeview
            delete-widget:git-hub-treeview

          /*
           * Adding our treeview items.
           */
          split:x:/../*/_arg?value
            =:int:8
          add:x:/../*/create-widget/*/*/*/items/*/*/items
            src:x:/../*/.folders/*
          set:x:/../*/create-widget/**/root?name
            src:x:/@split/1?name

          /*
           * Creating our actual treeview.
           */
          create-widget:git-hub-treeview
            parent:results-wrapper
            class:col-xs-12 col-md-6 prepend-top git-hub-tree
            widgets
              sys42.widgets.tree

                /*
                 * Lambda callback for when an item is selected.
                 * We just simply retrieves files and folders, and create our 
                 * Markdown "files datagrid" here.
                 */
                .on-select
                  sys42.samples.git-hub._get-files-folders:x:/../*/items/*?name
                  add:x:/../*/sys42.samples.git-hub._create-files-grid
                    src:x:/../*/sys42.samples.git-hub._get-files-folders/*/.files
                  sys42.samples.git-hub._create-files-grid:x:/../*/items/*?name

                /*
                 * Lambda callback for retrieving child items.
                 * We retrieve the files and folders, and returns items to caller (TreeView).
                 */
                .on-get-items
                  sys42.samples.git-hub._get-files-folders:x:/../*/_item-id?value
                  add:x:/../*/return/*/items
                    src:x:/@sys42.samples.git-hub._get-files-folders/*/.folders/*
                  return
                    items
                items
                  root:x:/../*/_arg?value
                    items

          /*
           * Making sure we initially select the root tree item, and populate our
           * datagrid with the root Markdown files.
           */
          add:x:/../*/sys42.widgets.tree.select-items/*
            src:@"""{0}"""
              :x:/../*/_arg?value
          sys42.widgets.tree.select-items:git-hub-treeview
            items
          add:x:/../*/sys42.samples.git-hub._create-files-grid
            src:x:/../*/.files
          sys42.samples.git-hub._create-files-grid

        /*
         * Creates the "datagrid" that shows our files.
         * Expects [.files] being collection of files to create our "datagrid" around.
         */
        sys42.samples.git-hub._create-files-grid

          /*
           * Deleting any previously created datagrids, if existing.
           */
          if
            fetch:x:/0/0?value
              widget-exists:git-hub-datagrid
            delete-widget:git-hub-datagrid

          /*
           * "Databinding" our datagrid.
           */
          apply:x:/../*/create-widget/*/*/*/*/tbody/*/widgets
            src:x:/../*/.files/*
            template
              tr
                onclick

                  // Databound above.
                  {_url}:x:?value
                  sys42.samples.git-hub._create-file-view-widget:x:/@_url?value
                  set-widget-property:x:/../*/_event?value
                    class:active
                  p5.web.viewstate.get:sys42.samples.git-hub.active-row
                  if:x:/@p5.web.viewstate.get/*?value
                    and
                      fetch:x:/0/0?value
                        widget-exists:x:/@p5.web.viewstate.get/*?value
                    delete-widget-property:x:/@p5.web.viewstate.get/*?value
                      class
                  p5.web.viewstate.set:sys42.samples.git-hub.active-row
                    src:x:/../*/_event?value
                widgets
                  td
                    {innerValue}:x:?name

          /*
           * Creating our actual datagrid.
           */
          create-widget:git-hub-datagrid
            after:git-hub-treeview
            class:col-xs-12 col-md-6 prepend-top git-hub-grid
            widgets
              table
                class:table table-hover
                role:button
                widgets
                  thead
                    widgets
                      tr
                        widgets
                          td
                            innerValue:"Files"
                  tbody
                    widgets

        /*
         * Creates the "file-view" widget that shows the content of our files.
         * Expects URL to file to display as [_arg].
         */
        sys42.samples.git-hub._create-file-view-widget

          /*
           * Deleting any previously created markdown widgets, if existing.
           */
          if
            fetch:x:/0/0?value
              widget-exists:git-hub-markdown
            delete-widget:git-hub-markdown

          /*
           * Massaging URL.
           */
          replace:x:/../*/_arg?value
            src:"https://github.com"
            dest:"https://raw.githubusercontent.com"
          replace:x:/@replace?value
            src:"/blob/master/"
            dest:"/master/"

          /*
           * Retrieving Markdown file, creating HTML out of it, 
           * and creating our result widget showing file.
           */
          p5.http.get:x:/@replace?value
          if:x:/@p5.http.get/*/result/*/Content-Type?value
            !~:text/plain

            // We only handle text types of files.
            sys42.windows.info-tip:File is not a text file.
            return

          // Checking type of file.
          if:x:/@replace?value
            ~:.md

            // Markdown file.
            index-of:x:/@replace?value
              src:/
            split:x:/@replace?value
              =:x:/@index-of/0/-?value
            markdown2html:x:/@p5.http.get/**/content?value
              root-url:{0}/
                :x:/@split/0?name
            create-widget:git-hub-markdown
              parent:results-wrapper
              class:col-xs-12 prepend-top git-hub-markdown
              element:div
              innerValue:x:/@markdown2html?value

          else

            // Source code file.
            p5.html.html-encode:x:/@p5.http.get/**/content?value
            create-widget:git-hub-markdown
              parent:results-wrapper
              class:col-xs-12 prepend-top git-hub-markdown
              element:pre
              oninit
                p5.web.send-javascript:@"hljs.highlightBlock(p5.$('{0}').el);"
                  :x:/../*/_event?value
              innerValue:x:/@p5.html.html-encode?value

      widgets

        /*
         * This is our input for having user supply the URL to some GitHub project website.
         */
        container
          class:input-group
          widgets
            span
              class:input-group-addon
              innerValue:URL
            void:url
              placeholder:GitHub project's URL ...
              class:form-control
              accesskey:U
              value:"https://github.com/"
            container
              class:input-group-btn
              widgets

                /*
                 * Button will download main GitHub project's landing page, 
                 * and semantically parse the HTML for any sub-folders and all of its source files.
                 * Will use this result for creating a "folder Ajax TreeView" to allow you to browse
                 * the project structure, in addition to a "files datagrid" allowing you 
                 * to view the content of each file.
                 */
                button
                  class:btn btn-primary
                  innerValue:Fetch
                  onclick

                    /*
                     * Clearing out any previous results.
                     */
                    clear-widget:results-wrapper

                    /*
                     * Retrieving root URL for project, and fiding all "xxx.md" types of files, 
                     * in addition to all folders.
                     */
                    get-widget-property:url
                      value
                    sys42.samples.git-hub._get-files-folders:x:/@get-widget-property/*/*?value

                    /*
                     * Verifying that we actually found something worth looking at.
                     */
                    if:x:/@sys42.samples.git-hub._get-files-folders/*/*
                      not
                      sys42.windows.info-tip:No folders or files found at specified URL
                        class:info-window info-window-error
                      return

                    /*
                     * Creates our Ajax TreeView for navigating folders.
                     */
                    add:x:/../*/sys42.samples.git-hub._create-tree-view
                      src:x:/@sys42.samples.git-hub._get-files-folders/*(/.folders|/.files)
                    sys42.samples.git-hub._create-tree-view:x:/@get-widget-property/*/*?value

        /*
         * Used to hold our results widgets.
         * Both the TreeView, DataGrid and markdown/code widgets are appended as children into this bugger.
         */
        container:results-wrapper

Then create a “lambda” page in the CMS of System42, with the following code in it, to consume the widget we created above.

/*
 * This will create a page, consuming our newly created 
 * extension widget.
 */
create-widget
  parent:content
  class:col-xs-12
  widgets
    sys42.samples.git-hub.file-browser

Notice, this code example, like most other examples here on my blog, requires both Phosphorus Five, in addition to System42.

PS!
If you want to use the above as a “persisted extension widget”, you’ll need to stuff it in a Hyperlambda file, and make sure your file is evaluated as the server is started.

PPS!
This code is dependent upon the very latest release of both Phosphorus Five and System42 to function, version “Zen 2.1” that is.

KUDOS

KUDOS to highlight.js; I want to give som KUDOS to the guy who created highlight.js, which is a great JavaScript library, allowing anyone to easily show code as syntax highlighted in their web projects. Thank you Ivan Dementev for Open Source licensing your great library. Great work dude! πŸ™‚

In addition, I want to give KUDOS to the Knagis for sharing his brilliant CommonMark.NET library with the world! Great work! For the record, I have a feature request for you, which is to have the option of having a separate URL resolver for images and hyperlinks. Pliiis …? πŸ™‚

BouncyCastle, the only real alternative for cryptography on .Net/C#

BouncyCastle is a group of cyberpunks from Australia, that have created a really kick ass cryptography library for Java and C# (or any other language on the .Net platform).

It’s a kick ass quality piece of work, with tons of features, supporting most standards out there in regards to cryptography. And I freakin’ love it! However, I must admit, that it suffers from an extreme lack of good documentation. You’ll find some information about it over at StackOverflow.com. However, in general terms, you’re basically “on your own” when trying to understand the thing. If you have a lot of spare time though, you could probably dissect its unit tests, to at least get a basic understanding of some of its features, but that’s clearly not for the faint at heart.

Phosphorus Five is using a lot of the features from BouncyCastle. In fact, for the most parts “indirectly” through MimeKit, where Jeffrey Steadfast has done an incredible job at abstracting away the gory details of BC. And I have even gone further to take away the pains, on top of MimeKit again.

Cryptography is one of those things you really should not create yourselves. The reasons are, that a simple bug, might literally mean the difference between life and death for your customers. Hence, instead of using BouncyCastle directly, which is a real pain – I encourage you to at least use it indirectly through MimeKit, or even preferably even through Phosphorus Five. That way, you’ll get a flying start, being capable of easily creating, at the very least some PGP encrypted emails, and creating your own PGP keys, etc – Without running the risk of messing everything up …

Check out the docs for how to get started hereΒ – (scroll a little bit down to see how to create your first encrypted email) – Below is a small video I created, that should get you started, within 5 minutes. So what are you waiting for?

Let’s Encrypt!!Β πŸ˜€

EU proposing ban on cryptography backdoors

No more of this please …!!

Finally som sanity! It now seems that EU is trying to push for a new law, which criminalises any attempts at installing backdoors, that will bypass cryptography solutions. Source; The Telegraph. I must say, that this is a surprising turn of events, since a lot of governments have made the exact opposite arguments, for quite some time. I guess they finally realised that it’s ipso facto impossible to keep our government communication secured online, unless they commoditise the same security to their people!

Thank you EU! Thank you very much!! ❀

PS!
Phosphorus Five has tons of cryptographically secured goodies … πŸ˜‰

MimeKit, simply the best MIME parser out there for C#

I have done a lot of work on MIME, meaning the Multi purpose Internet Message Exchange standard. This standard is at the heart of being able to send and receive emails, over e.g. POP3 and/or SMTP – Which are the two most commonly used standards for retrieving and sending emails.

Every time you want to send an email, you are basically using the MIME standard, which allows for “multiple entities”, such as attachments, HTML views, plain text views, etc. Hence, at least having a partial understanding of how MIME works, is crucial in order to be able to create software that somehow sends or retrieves emails. I have researched several different MIME parsers in the .Net space, and I have concluded with the following basically.

Unless you’re using MimeKit, you’re doing something wrong!

Every now and then, some geek comes around, and is able to do some really incredible thing. Jeffrey Steadfast is one of these guys. He has created the fastest MIME parser in existence previously in C, and over the last couple of years, implemented a MIME parser for the CLR. MimeKit can be found here. If you don’t believe me, look at his performance benchmark of his own baby compared to the alternative MIME parsers out there, at his GitHub website for MimeKit.

MIME is a notoriously difficult to understand standard (like most of them are), full of arcane language, and cross-references to other standards. Luckily, Jeffrey have created a brilliant API, which allows you to more easily understand how to create MIME messages, without having to wade through tons of documentation.

Below I have a video, demonstrating encrypting and putting more than 5000 PNG files into a single MIME message, using MimeKit at its core. On my MacBook Air from 2015, it is able to do that job in roughly 7 seconds. For the record, that’s staggeringly fast!

Even Microsoft has publicly announced that it is the superior MIME parser, indirectly, by making it become the recommended MIME parser, through making the old SmtpClient obsolete, and encouraging its users to use MailKit instead. MimeKit simply rules!

Why is software development hard?

Wouldn’t you rather want to be here, than in your office?

When Henry Ford invented the assembly line, he reduced the cost of creating cars by one order of magnitude, within some few years. When Gutenberg invented the printing press, he reduced the price of copying a Bible from a small fortune, to the point where you literally get them tossed after you by missionaries today. Obviously the software industry is not “entirely there”.

According to studies in the subject, 25% of all software projects completely fail, while 50% of them are “challenged”. Hence purely logically, we’re at the point where we’re “trying to build cars, with nothing but a hammer and a chisel”, right? Software developers work 80 hours a week often, trying to meet unrealistic expectations, effectively “outsourcing” their lives in the process. Obviously there must exist some tool for us as software developers, that gives us the same effect as the assembly line, or the printing press, right …?

I have invented such a tool in fact. It’s called Phosphorus Five, and allows you to become at least 10x as productive, and sometimes produce up to 220 times better results.

Don’t believe me, then check it out for yourselves!

When you’ve found my claims to be true, feel free to join me at the beach … πŸ˜‰

I’ll do 90% of your work for β‚¬57

Software development is a weird profession in many ways. For instance, if you can solve a problem once, the cost of solving the same problem 1 billion times, is the price of copying a file.

That I will do 90% of your job for €57 might sound weird. After all, you’re likely being paid 50-100.000 dollars per year for doing your job today. The idea that I will do 90% of what you do today, for €57, might at first seem ridiculous. However, I have already done most of your job! Assuming you’re a web developer at least.

This is because all software projects have similar problems. For instance, most of your web apps requires you to solve some repeating problem, over and over again, for each project you do. If you could extract the commonalities for your solutions, and create a re-usable component out of them, you would end up with having permanently solved that problem, for the rest of your life!

I have created software since I was 8 years old. I am 43 today. In 2011 I had a somewhat nervous breakdown, due to having worked 80 hours a week, for almost 20 years straight. I quickly realised that I am not alone in these regards. Most developers are suffering from inhumane expectations, and hence tends to burn out long before they’re supposed to retire. I decided to bounce back, and solve this problem, out of compassion for other developers.

All the software that we create, have basically 90% of its problems in common. I have been able to over the last 5 years, pinpoint these commonalities, extract them, and create generic solutions for them – At least when it comes to web apps development, and especially within the enterprise space.

In order to do this, I had to create a new programming language called “Hyperlambda”, Β invent a new way to create Ajax, and create a new design pattern called Active Events – To significantly reduce the complexity of having components integrate with each other, and play together, almost the same way the musicians in a symphony orchestra plays together.

In this process, I was able to improve your productivity 10x, improve the quality of what you create with sometimes as much as 100x, eliminate 90 percent of your potential bugs, and increasing the security of your apps by at least one order of magnitude.

The funny thing, is that you don’t have to believe me. In fact, I want you to disbelieve me! Only by being critical to my claims, you can become able to find the truth for yourselves. I have therefor chose to create my solutions as Open Source and Free Software solutions, to allow anyone wanting to test my claims to download it for free, for themselves to verify my claims. You can find my code at GitHub.

Then after you have found my claims to be correct, you can purchase a commercial license, that allows you to create closed source apps. Just please remember, that the €57 offer is only valid until the 15th of July 2017!

If you think I am full of bullshit, and don’t care to spend time checking out my claims – Then please realise that I have been published twice in MSDN Magazine about my ideas!

If Microsoft is willing to give my ideas some space, wouldn’t it be wise for you to do the same …?