...by Daniel Szego
"On a long enough timeline we will all become Satoshi Nakamoto.."
Daniel Szego

Monday, January 30, 2017

How to build up consulting business based on the technology Blockchain

Considering the fact that Blockchain is in the Hype phase it is important to analyse the possibilities how consulting business can be built up based on the technology. If we consider the standard consulting business, Blockchain has more or less similar characteristics as the standard technologies:

- Infrastructure: Infrastructure consulting is relevant if we consider private or corporate Blockchain solutions. In these scenarios it is important to analyse how many P2P nodes should be set up, where should be these nodes set up considering the internal corporate networks and firewall settings. In case of a public Blockchain solution infrastructure consulting is much less relevant. 

- Development: certainly the most important part of each application is the development. It contains on the one hand implementing Blockchain Apps, like Smart Contracts on the Blockchain, on the other hand related applications like web user interfaces communicating with the Blockchain. 

- Testing - Quality Assurance: This part is much more important than with standard software development as Blockchain applications usually planned to be highly secure highly available applications usually with strong cryptography requirements.  

- Classical Consulting: As the field is pretty complex general consulting is an important element of the area as well. Typically simply choosing the necessary Blockchain platform might be a complex issues, like choosing between Proof of Work, Proof of Stake, or public private or corporate Blockchain solutions. If low-code or no-code applications will be possible for application development, importance of the general consulting will be much higher.    

Saturday, January 21, 2017

The dawn of Robo-Lawyers

Next target of the digital distribution might be the legal system especially consulting services of the legal systems. These systems are sometimes unnecessary over-complicated and required years of learning to get even the basic competence. It is currently in discussion rather with the  cryptocurrency regulations. However, apart from this field it is an interesting area to provide automated legal advisory services to everyone on affordable price.

Saturday, January 14, 2017

Creating a simple job shop smart contract on the Ethereum Blockchain

Let we create a simple job shop smart contract. For the first run, let we create a smart contract called Job having some variables like description, responsible for the job, an internal jobID and a state of the job.

On the other hand, let we create a JobShop smart contract that practically uses a mapping for storing the different jobs mapped to a fictive primary key called jobID and having two functions for creating and assigning jobs for an account. 

After having the job task or job address, the job status can be set to done. In real life scenarios certainly this simplified functionality can be extended with for instance more variables, events raised if a job has been finished or with delegation and reporting functionalities.  

Friday, January 13, 2017

Analysing optimal technology choice for a project based on agile technology curve

Considering a usual enterprise software architecture, we can usually consider three phases: There is usually a setup phase of the technology that is pretty slow and expensive despite covers not too many use cases (Q1). Most software development frameworks have an agile part in the middle that provides the possibility to cover uses cases very fast very agile on a low cost basis. At the end, there is usually an architecture limit of the technology where the basic framework has to be further developed (Q2). A relative big effort is usually required to implement uses cases after the technology limit implying slow and costly delivery (Figure 1). 

Figure1. Agile technology curve and the performance of a project.

Let we consider the above curve from another perspective, let we consider a P project with a set of uses cases and let we analyse the question if a given T technology is an optimal choice for the project. We can say: 

- A technology is under performing for a given project or a set of use-cases if only a small part of the agile part is used. In this case the technology is simply not used enough, considering the pretty expensive set up phase. In this case another technology is perhaps a better choice.

- A technology is optimal performing for a given project or a set of use-cases if a large part of the agile phase is used to cover the use-cases, meaning simple that setting up cost at the beginning pays off. This case is the optimal technology choice,

- A technology is over performing for a given project or a set of use-cases if  many use cases are implemented outside the technology limit, meaning that the project will be probably unnecessary expensive and slowly delivered because of the use-cases outside the technology limit. In this case another technology is perhaps a better choice

- A technology is not performing for a given project or a set of use-cases if we do not use anything from the agile middle phase of the technology, meaning that after setting up the software framework, use-cases only outside the technology limit are implemented. In this case another technology is surely a better choice   

Thursday, January 12, 2017

Creating a simple order process on the Ethereum Blockchain

Let we create a simple order workflow on the Ethereum Blockchain. The workflow imitates an order request, containing information on which material was ordered, how many items and on the order price. We define two smart contracts, on the one hand similarly to our previous example we define an ApprovementActivity. The activity realizes the usual Approve, Reject and Delegate functionalities as in our previous example, However the functionalities are extended with a callback function, that informs the original workflow as soon as the internal state has been changed. Additionally, there is an event that is raised to the client side, as soon as a new Approval set.

Code of ApprovementActivity is the following:

Workflow itself is realized by another smart contract, called OrderWF. The workflow is pretty simple, it is initiated with the necessary input parameters, sets the initial state and creates an activity to be approved. Communication regarding the state changed is realized by the callback function. As a second possible communication way a reference for the original workflow has been given over to the Activity, however this functionality is currently not used.

Certainly the process just an over simplified prototype version.  For a real scale solution additional functionalities should be built up, like reading the order details from the ApprovementActivity smart contract, working rather with groups than with individual addresses, fine tuning permissions and so on...   

Wednesday, January 11, 2017

Communicating with external datasource on the Ethereum Blockchain

Calling external API from a Solidity smart contract is basically not possible. However there is an indirect way to communicate with external data sources via internal variables, functions and events. Let we assume that we want to call an external API with three string parameters, parameter_1, parameter_2 and parameter_3 and expecting returning a ReturnValue string.  The only way to do it is to raise an event, implement and event handler on the client side to make the necessary call for the event and write the resulting variable back to the smart contract. 

A simple smart contract for the implementation can be seen int the followings:
 Certainly the template realizes efficiently only one call. If several calls are executed paralleled than further considerations are required.  

Several considerations have to be done however regarding security. One of the main idea behind Solidity is that everything is controlled by a decentralized consensus. If external data is used by a Blockchain application it is something that is not part of the decentralized consensus, implying a way for cheating or hacking the whole application. As a consequence extensive use of external data is surely not proposed for a Blockchain application. 

Creating a simple task for an approvement workflow on the Ethereum Blockchain

Let we assume that we want to implement a simple approvement workflow, practically containing one user task with a responsible person to be approved and there are three possible outcome of the task: approves, declined or delegated. For the sake of completeness, we assume that functionalities for logging and access method control are already available, as we described them in the previous blog, The approvement process has one special information field in our example ApprovementInformation that is the information to be approved. In real case scenarios this information is best realized by an explicit smart contract. 

The implementation is pretty much straightforward. The state is stored in the workflowState variable and modified by the Approve and Reject functions. Responsible person of the workflow is stored in the WorkflowResponsible variable; in current implementation only responsible person of the task can accept or decline, however everyone with a write access is allowed to delegate the task for someone else.   

Tuesday, January 10, 2017

Combining data governance and permissions on the Ethereum Blockchain - a basic approach

As we have seen in the previous couple of blogs, there is a possibility both creating permissions on the Ethereum Blockchain and implementing basic data governance protocolls as well. Now we try to combine the two approaches into an inheritance hierarchy to cover both approaches. 

The simplest way is to define an inheritance hierarchy starting with the basic logging - governance functionalities. 
As a second smart contract let we define a descendant of the Governance smart that implements only the access modifiers. 
As the next descendant we define the administrative functions for giving access to a user. It is important to note that this functionality must already be set by the modifiers making sure that only accounts with the necessary right can set further rights. Considering governance, there is the possibility to monitor both the attempts of access and the succeed of access. It is realized by the AdminAccessRole input parameter in our example. 

Last but not least, custom functions can be set by the necessary modifiers, both ensuring that only the account with a necessary right can access to the functionality and to make sure that both the access attempts and the successfully attempts are logged. 

Notes on paper based business cards

Paper based business cards must extinct. 
They do not have any function, they do not have any usage. 
After getting the card you usually get the contact on LinkedIn and throw away the card.   
People meet, they have mobile phones they should be able to exchange business information simply by two clicking on the mobile phone. 
Paper is not required.
It is only a waste of resources,     

Monday, January 9, 2017

Basic data governance on the Ethereum Blockchain

Let we assume that we have several information on the Ethereum Blockchain and we want to realize some kind of a governance. For the first run, we want to collect and monitor the information who had access to some of the critical data and when. The easiest way is to implement an event type for logging. It provides both the possibility to log into a specific storage area and the possibility that the event is raised online on the client side (for instance in a javascript UI).
Triggering the events can be done the best by modifiers, like one for read and one for write.

Lat but not least, the functions that are critical, like access to the critical variable in this example can be extended by the modifiers. 

Certainly, the pattern works much better with inheritance, like implementing the modifiers in an ancestor smart contract and simply using them in a descendant contract. It is important to note that Ethereum is a public Blockchain. As a consequence, in this example even if getVariable is explicitly logged, there is a little bit hacking way to read out the information from the ledger itself without using getVariable.   

An attempt to define the field: Machine Assisted Human Intelligence

At the beginning of the second machine age, life has become increasingly complicated especially if someone works usually online. The reason for that is simple, the amount of knowledge and information that can be easily accessed online has been being boomed in the last couple of years on the one hand because of more and more people getting online and sharing directly or indirectly information. On the other hand, we are at the age of an IoT revolution as well, where not only people, but billions of intelligent devices are getting online, implying a huge wave of device generated data. 

From an evolutionary and biologically perspective this situation is something that is pretty new. We have been aware of the limit our physical body and human perception for thousands of years and we have been making contiguously attempts to overcome these limitations. Examples ranging from the tools of the prehistoric age via the steam engine to the industrial revolution. As an example, let we consider the capability of the human body to be able to lift at most around 100 kg. That is known to be too little already several thousands of years, implying inventions to overcome the limit from different lifting devices to different crane tools. Another well known example is the limitation of the human perception not to see in the dark. Attempts were made to overcome this limit from simply lighting a fire in the prehistory age to the nowadays night-vision systems. However information overload is something that is from an evolutionary point of view totally new. The amount of information throughout the world was something that one could overview even hundred years ago. Nowadays, the existing information is being doubled in each three years, everything is online, everything is real time and in certain fields you need pretty much of it to work or to make decisions. The human brain is simply not capable to work with such a huge amount information and well as the requirements are pretty new, we are simply not sure where exactly are our limits.     

Good examples are for instance many IT fields, like cloud computing. The field did not exist 10 years ago, despite nowadays there are thousands of books of information about and it is being continuously increased. Working in a field like this requires huge amount of time to simply keep up with the information without doing anything productive. There are not many companies and business models that can support such a thing. As a consequence the need for extending information processing limits  of the brain is an always increasing and demanding field.  

On the other hand current trends of artificial intelligence and machine learning provide many intelligent tools that could be efficiently used extend the limits of the humans' recognition and information collecting process. These fields have rather the focus of creating something that is thinking - working - acting similarly as a human. However with the little refocusing the tools might be used not to copy something that already exist and slowly will not be sufficient for the modern world requirements but rather to extend the human's thinking capabilities. Certainly it should be analysed which AI tools and methodologies can be really used in this field as well: rather methods that produce at the end symbolic results in a human understandable way. With other worlds, let machines support our cognitive capabilities by gathering, analyzing, structuring and storing data.  

Fields of machine assisted human intelligence might be the followings:
- Integrated man-machine interfaces
- Integrated man-machine knowledge discovery
- Integrated man-machine learning and knowledge integration:
- Integrated man-machine memory or storage.
- Integrated man-machine decision making.
- Integrated man-machine collaboration

In this sense the field is located somewhere between cognitive science and machine intelligence, having perhaps more general elements from computer science (Figure 1).

Figure 1. The field of machine assisted human intelligence.

An example for such an ecosystem which already can be found practically in each car is the navigation system. The navigation system extends the human memory simply by storing all of the required maps. It helps with the integrated decision making by collecting online data about traffic collecting both from individuals and from automatic sensors as well, practically realizing an integrated knowledge discovery environment as well. Advanced navigation systems take into account the experience and preferences of the driver as well, providing at the everything on a human readable interface (which I would say can be further developed in the future).

Another innovative field that is emerging at the moment and can be regarded as machine assisted human intelligence is the robo-advisory trend of the fintech industry. 

Using permissions on the Ethereum Blockchain with Smart Contract Inheritance

As we have seen in the last two blogs, there is a possibility to use access for functionalities for na Blockchain on permission basis and on group and permission basis as well. One way to use the functionality efficiently is with the help of Smart Contract inheritance. The modifiers and the logic are implemented in an ancestor class, as a consequence they can be used on the exactly same way in the descendant class as well. 

Creating groups and permissions on the Ethereum Blockchain for a SmartContract

We briefly covered in the last blog how to create permissions for accessing information on the Ethereum Blockchain. Let we extend the model for administrating the access rights not on the individual user (address) basis, but with the help of groups and group membership. We are presenting only a simply version as a prototype; certainly more complex solutions can be built as well. 

As usual, let we create a smart contract, some state variables to access, some elementary access level presented by an enum and two mappings: groupAtomicRoleMapping for mapping an atomic role for a group, and groupsForMembers for mapping list of members for a group name. A constructor is also presented that creates the first Administrators group with an Admin atomic access level and puts the current user into the group. 

Secondly let we create four modifiers to check if the the account calling a function in a group having Read, Write or Admin atomic access. Additionally one modifier checks if the account is the owner of the Smart Contract. 

As a next step some functions are implemented to access to the data of the smart contract and setting access to groups or adding users to group. All functions are modified based on the right modifiers. 

Last but not least, a help function is implemented for string comparison and a destructor as well. 

First testing of the contract can be done in the browser version of solidity. As an example after creating the contract with Create (default zero constructor) we get exception for services that require Admin access. (Please note that in this example there is a type error for the AccessWithGroups constructor. In this way we make tests with or without executing the functionality in the constructor).

After calling the constructor AccesWithGroups constructor explicitly, the administrator group is created set with Admin access and the current account is put into the group. As a consequence we have access for functions like setGroupAccess

Certainly real life examples would require more considerations, like implementing functionality for adding or deleting groups, having the possibility for a group to have more than one atomic access level or just implementing error checking into the existing functions.  

Sunday, January 8, 2017

Creating permissions on the Ethereum Blockchain with SmartContract

Let we create a simply example for a permissioned Smart Contract on Ethereum Blockchain. Let we assume that we have the following atomic level of access:
- Read: reading information from the state of the Smart Contract.
- Write; Writing information to a Smart Contract.
- Admin: administration the roles.

Let we assume that the Smart Contract has a couple of variables in a struct for storing internal information an enum for storing atomic access information, a mapping for storing the access information for each account and and a constructor that guarantees that the creating account is registered as Admin
Let we create as the next step three modifiers to guarantee that certain functions can be called only by the necessary rights. 
Last but not least, we use the modifiers in the service functions to make sure that only people with the necessary right are able to reach the given service, In our example, we have three services: for reading out data, for writing data and for administrating access.

Certainly, getData functionality does not really cover the expected functionality. As Ethereum is a public Blockchain, the data can be practically read out from the Blockchain even if the getData function can not be explicitly called. 

Saturday, January 7, 2017

Notes on API Integration Frameworks and API query languages

Regarding general IT trends, hosted API solutions are getting more and more common. It implies that solutions will be built up in the future with integrating several API-s as a service. As a consequence frameworks will be more and more important to integrate API-s, to test them, to measure the availability of the individual API-s, or just simply query data efficiently. 

Notes on testing a Bockchain application

Testing a Blockchain application is actually fundamentally different as testing a custom software solutions. The problem is that the domain of a usual Blockchain solution is usually in a domain that requires high privacy and security. Theoretically, the Blockchain technology itself provides a certain level of privacy and security, despite there have been already a lot of hacking both for the Bitcoin protocol and for systems like Ethereum as well (for instance the DAO). Consequently, testing a Blockchain application requires much more competence in the direction of system hacking or cryptography than traditional testing methodologies. Instead of classical tests, perhaps a better way to set up an explicate set of advisories as possible attacks and show that the system is immune for these attacks. Another point to consider, if it is possible to test a Blockhain platform itself from an application that is built on top. 
One way in this direction to formulate the problem from a quality management point of view and give an explicit set of rules that should be kept at the implementation in order the system to be secure. Example for such an initiative is the CryptoCurrency Security Standard (CCSS) for defining implementation rules for Bitcoin applications. 

Another way might be the direction of mathematical proofs if the program works as expected. One initiation is the formal verification from solidity.

Friday, January 6, 2017

Setting up Ethereum development environment - tools

Being new in a programming language and environment it is sometimes a difficult to set up an initial development environment. We try to summarize the most important tools in the followings:

Solidity, browser edition (https://ethereum.github.io/browser-solidity/):
- lightweight development environment for coding in solidity. 
- good tool for developing and manually testing small contracts or simply to practice the language. 
- no-live Blockchain integration

Mist browser (https://github.com/ethereum/mist/releases):
- I would say this is the infrastructure part of Ethereum: fancy user interface for managing accounts, smart contracts, deploying into the test or live Blokchcain or simply initiating transactions between actors. 

Geth (https://geth.ethereum.org/downloads/):
- This is another tool on the infrastructure side. Geth is a command line tool for similar purposes as the Mist browser, like creating accounts, deploying contracts to the Blokchain or transferring ethere  between different accounts. It provides however extended functionalities. like setting up a private Blockchain or accessing to some of the detailed cryptographycal elements of an account.   

Ethereum Block explorer (https://etherscan.io/):
- It is an online monitoring tool for the live Ethereum Blockchain, providing the possibility to see accounts or transactions.

Ethereum Studio (http://blog.ether.camp/post/142794388568/ethereum-studio-is-ready-for-you, or https://live.ether.camp/):
- Ethereum Studio is a complex online integrated development environment to develop and test Blockchain applications, including both solidity and other javascript elements.

Additional practical tools (http://ether.fund/tools/):
- There are some additional tools that are nice to use, like Ethereum unit converter.

Wednesday, January 4, 2017

Serializing state into the Blockchain in Decentralized Business Process Management

Well serializing state for Decentralized Business Process Management (or simply DBPM) does not seem to be very complicated for the first sight If we consider Ethereum as a Blockchain solutions. Let we assume that we have custom workflow for approving a project budget, having the following properties: ProjectName, ProjectType, ProjectBudget.The first intuitive realization is a simple smart contract, called WF_ProjectBudget having the three properties as parameters and having a set get function for each: 

contract WF_ProjectBudget
 string ProjectName;
 string ProjectType; 
 int ProjectBudget;
    function setProjectName(string _ProjectName)
        ProjectName = _ProjectName;
    function getProjectName() constant returns (string)
        return ProjectName;

    function setProjectType(string _ProjectType)
        ProjectType = _ProjectType;

    function getProjectType() constant returns (string)    {
        return ProjectType;
    function setProjectBudget(int _ProjectBudget)
        ProjectBudget = _ProjectBudget;

    function getProjectBudget() constant returns (int)    {
        return ProjectBudget;

There is a problem however with this intuitive approach. As the parameters can be set one by one, there is no guarantee that they will be set in an atomic action, meaning that either all of the values change or none of them. Supposing that atomic action is required saving the workflow state, the following code might describe the situation better:

contract WF_ProjectBudget
 string ProjectName;
 string ProjectType; 
 int ProjectBudget;
    function getProjectName() constant returns (string)    {   
        return ProjectName;

    function getProjectType() constant returns (string)    {
        return ProjectType;
    function getProjectBudget() constant returns (int)    {
        return ProjectBudget;

    function setWFState(string _ProjectName, string _ProjectType, int _ProjectBudget) {
        ProjectName = _ProjectName;
        ProjectType = _ProjectType;
        ProjectBudget = _ProjectBudget;

It is important to note that although the construct seems to be pretty simple, it guarantees that the three values are set in an atomic transaction independently of any kind of possible errors, like network outage, validation node failure or heavy cyber attack.

In real life scenarios we should consider that not always the whole state but only a part of it is saved in a transaction. As a consequence, it might make sense to explicitly define atomic groups: group of variables that should be serialized together. Another drawback is that this model assumes the one contract - one workflow model. A more general model might be to work with structs instead of individual variables, in this way one general solidity contract can contain the storage interface for several different workflows:

contract WF_State
    struct ST_ProjectBudget{
     string  STProjectName;
     string ProjectType;
     int ProjectBudget;

    ST_ProjectBudget LatestProjectBudget;

    function WF_State(string _ProjectName, string _ProjectType, int _ProjectBudget)
        LatestProjectBudget = ST_ProjectBudget(_ProjectName, _ProjectType, _ProjectBudget);

    function getProjectName() constant returns (string)    { 
        return LatestProjectBudget.ProjectName;

    function getProjectType() constant returns (string)    {
        return LatestProjectBudget.ProjectType;

    function getProjectBudget() constant returns (int)    {
        return LatestProjectBudget.ProjectBudget;

    function setWFState(string _ProjectName, string _ProjectType, int _ProjectBudget) {
        LatestProjectBudget.ProjectName = _ProjectName;
        LatestProjectBudget.ProjectType = _ProjectType;
        LatestProjectBudget.ProjectBudget = _ProjectBudget;


Blockchain as a storage

From a technical point of view Blockchain can be regarded as some kind of a special storage system. It is much slower as for instance a replicated database system, however due to the P2P architecture the availability can be actually higher as at a replicated database. Certainly the 'hacking resistance' is much higher at a Blockchain solution as with other solutions, and of course a Blockchain is far less efficient (Figure 1).

Figure 1. Blockchain as a storage.

Ways of decentralization for Decentralised Business Process Management

Considering Decentralized Business Process Management (or simply DBPM), one of the major question is which part of the framework should be decentralized and which should be not. The system has at least three layers (Figure 1), so let we see which one should be decentralized:

- Data Layer: Data is the state of the system tha has an initial state and a final one between all transitions. That must be saved into the Blockchain, it is one of the key characteristic of the  Business Process Management solution. However, it might be considered if all state between all transitions are saved or only certain ones, working as a checkpoint of the system. As an example, it can be imagined that cross-company decentralized processes save states of transitions in the Blockchain only if they deal  with cross-company communication. Local steps that are internal for a company can be realized independently from the Blockchain. 

- Workflow and Rule Engine: Well it is the major question of only storage should be decentralized or computation as well, like workflow or business rules. Having decentralized storage only without computation provides us clearly the advantage that workflow transitions run efficient. However, if the system is hacked in a way, then perhaps a state is written into the Blockchain that is already 'hacked'. It would be certainly a tragedy. On the other hand, keeping the computation decentralized might provide an enorm computing capacity. 

- Low code editors and API-s: Low-code, no-code editors are usually user interface components that should not be considered to keep decentralized. However, it is an open question how it is possible to avoid that the system is hacked and a wrong state transition is simulated. 

Figure 1. Possibilities for decentralization.

As a conclusion, the best option should be to provide a customizable solution, in which both elements of the state and types of the transitions could be individually parametrized if they should be saved into the Blockchain and validated by a decentralized consensus or not.  

Monday, January 2, 2017

Notes on machine payable micro-services

With the appearance of the different cryptocurrency technologies, micro-payment services have become possible. So basically the next evolutionary step can already be predicted: cloud-micro services with the direct micro-payment possibility. There are some initiative for creating such an architecture for Bitcoin, like, https://21.co/, however I think the idea gets much more exciting if it changed to Ethereum. At Ethereum there is basically an amount of 'money' or gas that is payed for all of the execution that are validated by the Blockchain. It is not difficult to imagine an extended model where each execution independently if it is an internal call or a an external micro service cost a certain amount of 'money'. In this sense providing a backend service will be realized as a complex micro service integration task with complex financial impacts. 

Sunday, January 1, 2017

Technology hype-cycle, exponential growth and the s-curve

Classical technology hype-cycles usually have the following characteristics: After an over-estimated expectation curve there is a negative peak of expectations and on the long run, the somehow the expectations reach the real output of the technology (Figure 1).

Figure 1. Technology Hype-Cycle.

Surprisingly the first positive and negative peaks can be pretty well described with the the following model. We can assume that the technology is exponential, starting slow at the beginning in comparing with a linear growth but after reaching the "singularity" point accelerating fast. Human forecast on the other hand are usually linear, just because based on the human thinking it is much easier to imagine something that is linear. The difference of forecast and real performance of the technology, let we call it over expectations, shows exactly the previously demonstrated positive - negative peak characteristics (Figure 2). 

Figure 2. Exponential technology curve vs linear expectations.

The model can be further refined if we suppose that the technology itself is not exactly exponential but it has the characteristics of a typical technology. With other words let we assume that the technology has a typical s-curve, but the expectations are despite linear. If so the phase of 'slope of enlightenment' can be clearly identified (Figure 3).

Figure 3. Technology curve with linear expectations

The need for machine assisted human intelligence

As more and more information getting available on the internet, sometimes in a pretty well organised way, the natural question rises: how can one cope with dealing with this always increasing amount of knowledge and information. Several educational platform like Coursera already exist there is already a way for getting this knowledge in a very well structured and high quality way. Despite the amount of information is simply huge. As we hear practically every day the achievements of the artificial intelligence, the questions raise pretty much naturally: is there a way to support the systematic learning process with machine intelligence ? Is there a way that I get access for the knowledge somehow in a machine assisted modular way, that I do not have to learn everything by myself ?  And well basically the answer should not be just having some data mining algorithm to offer the next course if I have already finished one, but something much more efficient, like getting the whole knowledge instead of 2 weeks in 2 hours. 

Notes on disruptive educational technologies

Udemy, Coursera, Nanodegree, Getsmarter and a docent of different online educational platform have been being emerged from the void in the last couple of years. They are sometimes different regarding on the business model and the used technology: as Coursera and Getsmarter concentrate rather on getting the education from well-known universities, Udemy tends to be rather an open platfrom for everyone. It is however surprising that high-quality knowledge itself have become very cheap and very wide-spread. It will surely have disruptive impact both on the global education and on the job market as well.