IOTA Hackathon: Open Car Charging Network (Part 2)

PlugInBaby App in iPhone

+++UPDATE+++

We’ve stirred much interest in the issuance of our XSC token at the IOTA hackathon in Gdansk. We therefore decided to prolong our rewards campaign for IOTA developers for 1 week:

If you’re a developer who committed code to advance the IOTA network during the month of November, you’ll be eligible. If you think you’re eligible you can request up to 250 XSC until Friday, 1 December 2017.

Fill out this form now! Show us that you’ve got the right stuff!
Developer Incentives Program: Claim XSC Rewards

For more information on the CSC Blockchain Evolution Incentive Scheme, click here and here.

+++UPDATE+++

This is the second installment outlining the experiences of the winning team „PlugInBaby“ during the IOTA Hackathon. In the first post (found here), we describe the idea generation process.  In this post, team member Rebecca Johnson goes into more detail with regards to how the team built the project and what exactly it accomplishes.

Our PoC decentralizes and democratizes access to a  network of electric vehicle chargers by allowing the chargers to costlessly broadcast their status (offline, occupied, available) via 0 value transactions on the tangle. Next, using a mobile app, users searching for a charging station can query the tangle using 0 value transactions to search for tags of available stations. They can reserve a charging spot and book micro transactions necessary to pay for electricity, all using IOTA.

Concept Doodle
A world where individuals leverage open source software and DIY hardware to decentralise the market for energy.

Using the tangle as a database makes the solution quite elegant. The protocol for sending data and value are essentially the same which removes the need for a centralized payment processing layer and allows for the DIY ethic to extend all the way to the end-user.

This approach is also flexible enough to leave room for participation by utilities and other stakeholders since the hardware and software are open-source.  Improvements are welcome and anyone is free to implement the idea. The code can be found here.

Requirements & Assumptions

  • We restricted ourselves to using only IOTA for implementing the database functionality. This carries the theoretical advantages of future scalability, full decentralization and zero transaction costs for messages sent to and from the tangle as well as a mechanism for machine to machine electricity purchases.
  • We assumed that the API and the interaction between the charger and the car app are out of scope for the hackathon.
  • Charging station vendors need to send status messages for their stations (free, in-use, offline) using 0 balance transactions to the tangle. Our back-end provides this capability via terminal inputs. Since this is just a PoC we didn’t build out an API or UI for this portion.
  • A web-based front-end, a back-end connection to the tangle and an API for communication between the two needed to be built. Given this, the team split into two groups of 3-4 developers each.

Back-End:

The experience of the PlugInBaby team was similar to that of the Freedom Pass team. We started out by following this tutorial from Baltic Data Science and gained speed by utilizing some of the resources from the Q&A with Chris Dukakis of IOTA. After that, we connected to a testnet node and started issuing transactions.

Like the Freedom Pass team, we also considered using a mainnet node but the issue of how to connect with neighbors was eventually a knockout criterion. This was actually due to security concerns. One of our team members had a Java Runtime Environment setup on a remote virtual machine and we considered setting up an instance of the IRI. In the end, however, we weren’t comfortable with the security risks that connecting with unknown nodes presented.

In contrast to the other teams, the „PlugInBaby“ team used the IOTA Python Library to build and connect the backend. Documentation for this library is quite sparse in comparison with the JavaScript Library. We’d like to thank Andreas OsowskiLewis Freiberg and  Chris Dukakis of IOTA for their round-the-clock support in getting everything up and running.

Our team member Lukasz Zmudzinski has written a great blog post on his site which outlines which Python methods we used to read and write to the tangle in greater detail. We used the Tornado web framework and asynchronous networking library for this project and wrote our own API  to communicate with the front end.

Team PlugInBaby hard at work on frontend development

Front End:

The front end was written primarily in JavaScript and utilizes server.js for Node.  To accelerate development we started using a boilerplate/skeleton for Node.js web applications. We later used bootstrap and AngularJS to improve the styling and make our web app mobile-ready and responsive.

Users can query the tangle for the transactions of vendors with free stations and also read dynamic pricing information. The search mechanism uses information written to tags while the state information about the charging station and the station latitude/longitude are written in the message. This information is then passed via API calls to the front-end for interpretation in the UI.

User Experience:

UI Workflow
UI Workflow
  • Step 1:
    The user uses a smartphone app to query the tangle for available charging stations.
  • Step 2:
    The user selects a charging station from the map. Each station has dynamic pricing which is shown in real-time along with the map pin when selecting the station.
  • Step 3:
    The user drives to the station and lets the station know that they have arrived by sending a message to the tangle.
  • Step 4:
    The charging station tells the app that the car is fully charged.
  • Step 5:
    The user’s IOTA wallet is debited and the transaction is signed by the seed stored in the app.
  • Step 6:
    The charger resets its status to available on the tangle and all the transactions/messages are available for verification.
Tangle Output
IOTA Tangle output: Following charging all transactions are available for inspection in the tangle.

What We Learned:

The PlugInBaby PoC demonstrates the feasibility of an IOTA-based search and payment app for IOTA-based DIY chargers but it is far from ready-for-use outside of the lab/hackathon. A number of issues came up which will need to be solved before this system would be appropriate for public use.

  • Tags only allow for 27 characters which wouldn’t be enough to store latitude and longitude data plus a transaction ID without truncation. The team ended up using the message field to store data (location + charger status) while the tags were used to store a searchable charger identifier.
  • Speed is quite limited on the testnet. Specifically, we found that the testnet confirmation times were quite long late at night (2-3 minutes) when fewer users were online running test applications. This is due to the fact that each new transaction must approve two other transactions. This approach scales well but also requires many active nodes to submit and approve transactions. As both the testnet and the mainnet grow this problem should be mitigated.
  • Transaction caching was required to make the demo useable within the alloted three minute presentation time.
  • While the support from the IOTA team was excellent, we noticed that the documentation, particularly regarding the phython libraries, is quite lacking. This makes development a slow trial and error process.
  • Security and privacy are generally open questions within the IOTA ecosystem. The team assumed these issues to be outside the scope of this PoC. That said we raised privacy concerns regarding the possibility of API misuse and the lack of privacy often during the development process. Improved documentation and more descriptive error messages would go a long way towards making these issues easier to handle.
  • Masked Authenticated Messaging (MAM), the planned Private Transaction layer, and the integration of zero-knowledge-proofs into the IOTA ecosystem are exciting areas for new research given the current limitations of IOTA in the area of security and privacy.

Conclusion

To sum up, the team learned a lot about the implementation of an exciting use case that really makes sense for IOTA. Is this the only way to build such a system? No.  There are many other ways to find, navigate to and pay for electric vehicle charging. Many market-ready centralized systems are already up an running.  Our PoC demonstrates, however, that it’s possible to solve this use case using IOTA alone which allows for the possibility of a scalable decentralized approach. This, in turn, could open up the field to many more players and provide a common system for various entities to build upon.

Hackathon Participants
Team „PlugInBaby“ at the IOTA Hackathon in Gdansk, Poland

 Here is an overview of all reports on the IOTA Hackathon’s projects:

1st place – „PlugInBaby“:

…describes the idea and the pivot of the project
Team „PlugInBaby“: Open Car Charging Network (Part 2)
…describes the technical level and provides resources

2nd place – „Freedom Pass“:
Team Freedom Pass: Fraud Detection (Part 1)
…describes the high level of the project
Team Freedom Pass: Fraud Detection (Part 2)
…describes the technical level of the project

IOTA Hackathon: Open Car Charging Network (Part 1)

PlugInBaby App in iPhone

+++UPDATE+++

We’ve stirred much interest in the issuance of our XSC token at the IOTA hackathon in Gdansk. We therefore decided to prolong our rewards campaign for IOTA developers for 1 week:

If you’re a developer who committed code to advance the IOTA network during the month of November, you’ll be eligible. If you think you’re eligible you can request up to 250 XSC until Friday, 1 December 2017.

Fill out this form now! Show us that you’ve got the right stuff!
Developer Incentives Program: Claim XSC Rewards

For more information on the CSC Blockchain Evolution Incentive Scheme, click here and here.

+++UPDATE+++

The IOTA Hackathon took place from Nov 17 to Nov 19 in Gdansk, Poland. Software developers from all over Europe came together to put to test the IOTA Platform with various use cases. The event was sponsored by IOTA, Baltic Data Science (blockchain and big data service), Datarella (blockchain and big data consultancy) and Bright Inventions (mobile app development). Four teams of developers and software experts formed around various use cases and competed for the prize money of 4,200 IOTA. Here in „Part 1″ we summarize the idea iteration process for the contest’s winning team  „PlugInBaby“ and the associated pivot that took place while defining the project topic. Part 2 describes the development and design of the project in more detail.

Defining the Need

Idea Consolidation
Idea Consolidation

We started the hackathon with a group brainstorming session followed by some informal voting and group building around the topics generated.

After narrowing the focus down to the topics, „Autonomous Agents“ and „Decentralized Stack“ the group focused on idea generation.  Any potential topic needed to utilize the special characteristics of IOTA (scalability, speed, zero transactions costs) while avoiding limitations such as the lack of a Turing complete language and smart contract capabilities.

Initial brainstorming considered applications in manufacturing, autonomous transportation, supply chain management and distributed sensor technology.  Eventually the basic idea of using IOTA as a distributed database allowing individuals or autonomous agents to identify free parking spaces in cities and also search for those spaces crystalized out of the brainstorming process.

Pizza Box Brainstorming
Pizza Box Brainstorming

After several hours of work on the concept and the potential implementations, we found structural problems with the plan. In our initial approach, the team imagined that individuals or autonomous agents/smart cars would identify free parking spaces, notify others of their presence by writing to the tangle and potentially be compensated for the service. A number of important questions were however left open with this topic.

Critical Questions that Lead to the Pivot:

  • Why should a system for finding free parking spaces be built using IOTA?
  • Wouldn’t another technology be more appropriate?
  • Why not use a blockchain which allows for smart contracts?
  • Would people really use such an app?

Pivot to an open car charging network

After several hours of discussion, the team still couldn’t adequately answer the above questions so we turned to another idea. Instead of logging free parking spaces, we would provide a link between an IoT network of decentralized charging stations and traditional or autonomous cars needing charging services.

Currently, electric charging infrastructure is almost always mediated by large corporations and organizations. This project seeks to change this.  The team drew inspiration from ElaadNL which built a Proof of Concept (PoC) Charging Station for electric cars running fully on IOTA. Their charger is built using off the shelf tech and could be adopted by individuals who wish to offer electricity from their private microgrid or solar installations. What’s missing in the ElaadNL implementation is a user-friendly way to select and navigate to the charging station.

ElaadNLPoC
ElaadNL IOTA Electric Car Charger PoC

The ElaadNL PoC app works on a „Pull“ basis where the user has to enter a charger code to search for the status of a particular charger.  The team wanted to design something that would work on a „Push“ basis and push the location of open chargers to users within the familiar confines of a google map interface.

The team envision a world in which individuals could take an open-source IoT charger kit and set up an IOTA-based charging station wherever they have access to power and a parking space. This could open up a whole new layer of community-based decentral charging.

Concept Doodle
A world where individuals leverage open source software and DIY hardware to decentralize the market for energy.

The project, so conceived was well matched with the strengths of IOTA. Scalability and transaction speed would be needed due to continual improvements in the speed of charging and the fact that the search mechanism of the system would have to operate very quickly to guarantee a good user experience. A system with zero transactions costs was also judged to be appropriate for the type of microtransactions that need to occur between a car and a smart charger enabling real-time pricing for electricity.

We owe a shout out to ElaadNL for their PoC. The existence of such charger allowed us to think in a modular fashion and abstract away the charger component to focus instead exclusively on the building a system to find the chargers and transact with them.

IOTA Hackathon winning team „PlugInBaby!“. Team members (from left to right): Yoon Kim, Andrew Young, Rebecca Johnson, Lukasz Zmudzinski, Dominik Harz, Alexei Zamyatin, Linna Wang, Nicolas S – and the moderator Michael Reuter of Datarella to the far right

 Here is an overview of all reports on the IOTA Hackathon’s projects:

1st place – „PlugInBaby“:

…describes the idea and the pivot of the project
Team „PlugInBaby“: Open Car Charging Network (Part 2)
…describes the technical level and provides resources

2nd place – „Freedom Pass“:
Team Freedom Pass: Fraud Detection (Part 1)
…describes the high level of the project
Team Freedom Pass: Fraud Detection (Part 2)
…describes the technical level of the project

IOTA Hackathon: Fraud Detection (Part 1)

The IOTA Hackathon took place from Nov 17 to Nov 19 in Gdansk, Poland. Software developers from all over Europe came together to put to test the IOTA Platform with various use cases. The event was sponsored by IOTA, Baltic Data Science (blockchain and big data service), Datarella (blockchain and big data consultancy) and Bright Inventions (mobile app development). Four teams of developers and software experts formed around various use cases and competed for 4,200 IOTA in prize money.

This article describes the lessons learned by the „Freedom Pass“ team, which Kira Nezu from Datarella coached. The technical part of the lessons learned can be found here „IOTA Hackathon – Lessons Learned: Fraud Detection (Part 2)“ by the team member Jonatan Bergqvist. The team placed 2nd in the competition.

1. The Task

The team was joined by Bogdan Vacusta, who brought a real-life challenge from the London Council to the IOTA Hackathon. London Councils issue „Freedom Passes“ to disabled residents which allow them to use public transport within the city free of charge. Prior to the issuance of a Freedom Pass, one must obtain a doctor’s certificate to prove disability.

Pizza boxes served as flipcharts for use case scenarios

Unfortunately, scammers have successfully been photoshopping doctor’s certificates for perfectly healthy London residents. No one knows for sure how many Freedom Passes have been issued under false pretenses but the number is likely in the thousands. London Councils have no procedure in place to verify if a certificate has been faked. A simple alert, when one doctor has issued an unusually high number of certificates would be a huge step in successfully detecting fraud.  This step alone could save the public tens of millions of Pounds per year with the help of IOTA.

London Councils loose tens of millions of Pounds per year to fraud

The team’s task was to build a Proof of Concept (PoC) to prevent fraud. So, how can IOTA be used for fraud detection?

2. The Solution

The team decided to create a transaction from the doctor to the applicant, thus certifying the disability of the applicant on the IOTA Tangle. If an anomaly in the number of issued certificates of a doctor occurs, the system alerts the London Councils.

In an ideal scenario, the doctor would issue this digital certification from an app (mobile or web based), signing the transaction with her private key (this measure would actually help prevent fraud). Given the short timeframe at the IOTA Hackathon (less than 24h), the team chose to create sample data and to carry out the transaction on the doctor’s behalf for the PoC. A local database would be fed the details of the doctor and the applicant, as to identify them. So, the system for the PoC was to include the following components:

  1. An input form for doctor and applicant data
  2. An interface to the IOTA Tangle
  3. A database with doctor and applicant data
  4. A backend which analyses the data
  5. A frontend for the London Councils with a list of alerts
System Architecture for fraud detection with IOTA. From the doctor’s ID and applicant’s National Insurance Number, a Seed is generated (you can think of a „Seed“ as a key to access your data on IOTA).

3. The Process

Here’s is how it works:

1. Entering the data
The doctor’s and applicant’s data is entered via a web-based user interface (the team actually populated the database by writing a JavaScript method that wrote the fake data directly to the database, so this UI – although functional – was not needed for the PoC. You can learn more about this in part 2 of the lessons learned):

User interface for entering application data

2. Certification
The data is written to the local database. Simultaneously a transaction – symbolizing the disability certificate – from the doctor to the applicant is immutably written to the IOTA Tangle. The transaction ID is, in turn, written to the local database adding the ability to prove that the certification has taken place.

3. Analysis & Reporting
The backend analyses the data and alerts the officials in case of any anomalies. ie. (If one doctor has issued unusually many certificates within a certain time frame.)

Anomaly report for issues doctor’s certificates

What we learned

We completed our goal within the timeframe despite running into issues due to working with an immature system along the way.  In the end, we managed to create a Proof of Concept perfectly suitable for the setting of the IOTA Hackathon.

We did run into a few issues along the way which must be addressed by the IOTA team in order to improve the system and make it fit for future use cases:

Speed of transactions: On the IOTA testnet we experienced long wait times when confirming transactions. Submitted transactions confirmed in ~1 minute, reading transactions took circa ~3-5 minutes or more depending on the amount of data. This may be a testnet issue independent of the mainnet.

The Documentation was not up to date, there was missing information and what documentation existed was somtimes misleading (i.e. Properties marked as optional are actually required, not obvious that a replayTransaction function creates a completely new transaction, sending a message instead of a transaction the sender is not documented on the tangle …)

Releases are not scheduled in advance, if an update is run during development, developers must adapt quickly to accommodate changes. A roadmap by IOTA for releases would be very helpful.

Node.js SDK is based on „callbacks“ (an old technology standard), not on „promises“ (current technology standard).

The API can easily be misused. Values and properties that shouldn’t be passed can go through without any error message. The API is missing descriptive error messages, leaving developers in the dark when it comes to hunting down bugs.

So, why IOTA?

Frist off, one might argue that this task could have been done with a regular database entirely. While this is true, a database is a lot easier to attack by hackers than a blockchain or tangle. Also, this kind of system could have been set up on a blockchain system s.a. Ethereum, why use IOTA? Well, the challenges blockchain systems are struggling to overcome are performance and scalability. Due to block sizes, transaction times constantly increase – thus making the systems less usable for scenarios in which transactions must happen near instantly.

IOTA helps to solve the problems of performance and speed of transactions. The team is in agreement that the IOTA Tangle and similar „non-block“ chain approaches are likely to be most feasible to enable scalability in future. Also, an application using IOTA can quite easily be transferred to related use cases.

Conclusion

Would the team recommend using IOTA for fraud prevention?
The answer is Yes, if the long term goal is to further develop IOTA in general. The answer is No, if the system should be used in a productive environment at this point, since it is still immature. Alternative systems which currently are more mature and could be used for the task include Hyperledger Fabric, Sovrin and Ethereum. These blockchain systems pose scalability issues in the future, whereas development here is also ongoing.

The IOTA application „Freedom Pass“ is very well scalable and transferable to related use cases. However, IOTA must undertake massive improvements regarding performance s.a. speed and documentation as well as for the API and SDK/node.js. If the above issues are continuously improved, the team recommends IOTA for further developing this kind of system for the public. IOTA promises future potential for the public for reconciliation of data, reduction of duplication, auditability, authentication.

Team „Freedom Pass“ at the IOTA Hackathon in Gdansk (from left to right): Michał Łukasiewicz, Kira Nezu, Bogdan Vacusta, Jonatan Bergqvist, Victor Naumik, Rafal Hofman, Artem Goncharenko

Continue to the technical report by Jonatan Bergqvist:
„IOTA Hackathon – Lessons Learned: Fraud Detection (Part 2)“

The team was supported 24/7 throughout the hackathon by members of IOTA – many thanks Chris Dukakis, Lewis Freiberg and Andreas Olowski for their time and effort!

 Here is an overview of all reports on the IOTA Hackathon’s projects:

1st place – „PlugInBaby“:

…describes the idea and the pivot of the project
Team „PlugInBaby“: Open Car Charging Network (Part 2)
…describes the technical level and provides resources

2nd place – „Freedom Pass“:
Team Freedom Pass: Fraud Detection (Part 1)
…describes the high level of the project
Team Freedom Pass: Fraud Detection (Part 2)
…describes the technical level of the project

IOTA Hackathon: Fraud Detection (Part 2)

This is the second installment in our posts about the experiences of the „Freedom Pass“ team during the IOTA Hackathon. In the first post (found here), Kira set the stage and explained the current issues of the London Freedom Pass. In this post, we’ll get a bit more detailed with regards to how we built the project.

DISCLAIMER: Even though the project is called „Fraud Detection“ the technological focus is very much on IOTA and not at all on machine learning-methodologies or data science, as one would commonly associate with fraud detection and prevention.

After we’d narrowed the scope down sufficiently to what we thought would be achievable during a hackathon, we started getting familiar with the IOTA tangle. We followed this tutorial for making a simple transaction, written only a few weeks earlier but already with some modifications required. After having gotten ourselves familiar with the general concepts of the Tangle (much accelerated by a presentation and Q&A by Chris Dukakis of IOTA) we connected to a testnet node and started issuing transactions.

Before we get into the details of the project, I’ll make a short comment about the decision whether to run a full node, the IOTA Reference Implementation (IRI) or to connect to pre-existing nodes. In short, to run the IRI, one needs a complete Java Runtime Environment, which is one of the reasons why IOTA can’t be run on an IoT device at this point. Each node connected to the tangle exposes an HTTP API through which transactions can be issued. To set up an instance of the IRI, one has to acquire the addresses of the already connected nodes in the tangle. The recommended way to do this is by asking people in the slack-channel #nodesharing. Because of the above restrictions and our requirements in time, we didn’t think it would be necessary to run our own node.

Back to the task of solving the problem of fraud in the application process for the Freedom Pass in London boroughs. We settled for the JavaScript library since it does a lot of the heavy lifting on top of the API and is by far the best-documented library. (The winning team used the mostly undocumented Python library and still managed to interact fairly smoothly with the tangle). The iota.lib.js implements both the standard API, some useful functionality like signing, unit conversion and reading from the tangle. In our project, we had set out to supply the following interactions between the tangle and our users:

  1. Register Doctor as a seed on the tangle
  2. Register Applicant as a seed on the tangle
  3. Perform a transaction for each certificate between the issuing Doctor to the Applicant.
  4. Verify that a certificate was registered on the tangle given a Doctor and an Applicant
  5. Read information off of the tangle about outgoing transactions from all Doctors

Given the above functionality, how could we leverage the existing IOTA library in the best way possible? Well, since smart contracts or most types of advanced transactions aren’t really possible on IOTA (yet), we will need some off-tangle processing, storage and UI.

For this, we implemented a backend and some wrapping to process the information from the applications. The server-side was written using Node.JS and the express-framework. To model the logic and structure of the database, we used MongoDB and mongoose. The MongoDB contained a simple key-value store, saving relevant applicant information. One could imagine that is could be upgraded to a graph-model to better mirror the tangle structure and to be able to more efficiently analyse connections between Doctors and Applicants, however, that was out-of-scope during the ~24h of coding we had.

In order for the user to interact with the tangle in an easy way, we built a small web-frontend. It allows the user to enter information about an application such as the national insurance number of an Applicant, postal code of the Doctor and Applicant, phone numbers, etc. At this stage, four things need to happen:

  1. The information is saved in the MongoDB-collection,
  2. seeds for the Applicant and Doctor are created based on an aggregate of identifying information,
  3. new test tokens are generated and sent to the Doctor’s account and
  4. an IOTA transaction is issued from the Doctor to the Applicant.

To save the information into a MongoDB-collection a controller instantiates and returns a new model containing the just entered data. It passes it on to the server.jswho handles the HTTP-requests from the client.

There is no dedicated IOTA API-call for generating seeds, but they do supply a command line command for generating a random seed. We made our seeds relatable to the private information by concatenating the private key with the national insurance number for the Applicants and the Doctor’s ID for the Doctors. After the seed was generated, a fresh address is created for each new transaction.

To make the functions from the iota.lib.js a bit more usable, we wrapped the existing callbacks-based structure in Promises. This allowed our code to become a bit more asynchronous than it is ‚out-of-the-box‘.

Here is an overview of the architecture:

„Freedom Pass“ System Architecture

Once the data and the transactions were issued, the next step was to provide a way of viewing the existing applications and certificates. So we created a second page of the UI for listing all applications with relevant information read from the MongoDB-collection.

UI for entering Doctor’s and Applicant’s data

This doesn’t, however, provide such a great way of finding the main type of fraud that we were considering, namely Applicants reusing information about Doctors. This makes it look like a single Doctor issued an unreasonable amount of certificates. A pretty easy case to catch, one would think, but considering it is a completely analog process done by on  paper in different boroughs by different administrators, it sums up to quite a large amount of faked applications. This is the type of fraud we focussed on in our processing.

So how can we in a user-friendly way flag cases that should be investigated? We chose the simplest option and created a second view of the UI where each Doctor in the system is listed along with the number of certificates they’ve, supposedly, issued. The list is sorted by the number of certificates issued. Here one could imagine making it a bit smarter by including the date the certificate was issued and creating a more differentiated metric of certificates per time unit, but it wasn’t in scope this time around.  If a Doctor issued more than 10 certificates, they were highlighted in red. A very simple but potentially efficient way of communicating to the user that something needs to be investigated. Of course, the number 10 was completely arbitrary and could have been chosen differently. In fact, to decide that number, one would have to, first of all, analyze historical data.

Hitlist of certificates issued by Doctors

To sum up, Team Freedom had a lot of fun and learned tons about IOTA, ideation, cooperation, and creation in a short time-frame. We managed to build a functioning Proof of Concept for how IOTA can be used for the secure issuing of medical certificates in order to prevent and detect fraud. The application to the Freedom Pass was done so that it would be easier to understand what was being done and why. But that does in no way mean that the base structure cannot be used for other purposes, in fact, it was written specifically to be general enough that it is also interesting in other areas.

Is this the only way that the problem could have been solved? No. Was it the easiest way of solving it? Absolutely not. However, we believe that only by experimenting and utilizing one of the few scalable and future-resistant distributed ledger solutions can we achieve applicability. There is, generally speaking, almost no distributed ledger application that could not have been done without the use of a distributed ledger, but it would have incurred great financial, organizational or trust costs. IOTA is a very cost-effective and scalable solution, but with the caveat that it is still in its infancy.

Freedom!
Team „Freedom Pass“ at the IOTA Hackathon in Gdansk, Poland

  Here is an overview of all reports on the IOTA Hackathon’s projects:

1st place – „PlugInBaby“:

…describes the idea and the pivot of the project
Team „PlugInBaby“: Open Car Charging Network (Part 2)
…describes the technical level and provides resources

2nd place – „Freedom Pass“:
Team Freedom Pass: Fraud Detection (Part 1)
…describes the high level of the project
Team Freedom Pass: Fraud Detection (Part 2)
…describes the technical level of the project

IOTA Hackathon

The blockchain tech sphere in the fall of 2017 looks totally different than in the same period of 2016. Then, many people heard about blockchain for the very first time, now there are several dedicated blockchain platforms for specific applications. In the field of Industry 4.0, beside supply chain and robotics, IoT applications provide a hotbed for highly scalable blockchains, such as IOTA, NEO, or QTUM.

For and with one of these IoT-specific blockchains, IOTA, we will organize a hackathon, a week-end full of code, co-creation and ideas.

BUILD THE FUTURE WITH US!

Today is blockchain, tomorrow is industry 4.0 and the internet of everything. Autonomous cars, sensors and intelligent factories are the future but how will they communicate and transact among one another on a worldwide scale? IOTA is a blockless ledger system which enables scalable autonomous machine to machine micro-transactions without fees. Want to get your hands dirty and take part in building the future?

WHAT’S THE IOTA HACKATHON ALL ABOUT?

  • Developing services or products for the internet of things
  • Gaining experience with IOTA’s blockless ledger system for cutting-edge machine to machine transactions
  • Keynote speeches by key players in the industry
  • Networking, fun, free food and friendly competition

THREADS TO BE PURSUED

  • IoT Based Business Plans
  • Hardware Connectivity Layer: Bluetooth, Z-wave, ZigBee or LoRa
  • Application Layer: MQTT, XMPP
  • Fog, Mist & Edge Computing for IoT
  • Quantum security
  • IoT Maintenance & Lifecycle Management
  • Identity of Things (IDoT)

WHO CAN PARTICIPATE?

  • Developers (Esp. JavaScript, Java, Python)
  • Business Practitioners & Economists
  • UI/UX Designers

SCHEDULE

FRIDAY 17 NOV
18:00 – 19:00
Reception and Networking: Get comfortable and get to know one another

19:00 – 21:30
Keynote Presentations: Introductions and food for thought
– Jörg Blumtritt (Datarella)
– Dominik Schiener (IOTA)

SATURDAY 18 NOV
9:00 – 9:30
Breakfast and Coffee: Fuel up for the Hackathon

9:30 – 10:15
Individual Introductions: Barcamp style three keywords per person
30 Second Elevator Pitches: Explain your idea, build a team that can execute it!

10:15 – 11:00
Team Building: Chat with team leaders of interest & decide which team you want to hack with.

11:00 – 12:00
Speakers round: Getting started with IOTA: Dev Tools & Resources from Baltic Data Science

12:30 – 13:30
Lunch Break: Enjoy some delicious food and get ready

13:30 – 16:30
Time to Hack: Build, Test, Iterate

16:30 – 16:45
Movement Break: Get your blood pumping!

16:45 – 19:30
Time to Hack: Build, Test, Iterate

19:30 – 20:30
Dinner Break: Take some time to nourish the body and get ready for the all nighter to come!

20:30 – Late
Hack Till Your Heart’s Content: It’s up to you. The accelerator is open all night. Code till you drop.

SUNDAY 19 NOV
9:00 – 9:30
Breakfast and Coffee: Fuel up for the final day

9:30 – 12:30
Hacking and Presentation Prep: Get your demos running!

12:30 – 13:30
Lunch Break: Nutrition for the final stretch

13:30 – 14:00
One Last Check: Audio Visual and Tech Check for Demos

14:00 – 16:30
Demo Presentations: Show us what you’re made of!

16:30 – 17:30
Jury Session: Enjoy some refreshments while the jury deliberates

17:30 – 20:30
Awards Ceremony: Celebrate with the winners, network and celebrate

APPLICATION
To apply for the IOTA HACKATHON 2017 register now!
Don’t wait for too long – the number of participants is limited.

LOCATION
Lęborska 3b, 80-386 Gdańsk
NIP: 583-290-74-40

Based on our experiences with hackathons we think that Gdansk, Poland, is a perfectly suited location for this IOTA hackathon. Looking forward to hacking with you!

Mobility and Net Neutrality

Driving by car is strongly connected with a feeling of personal freedom. While we book flights just for one specific itinerary, and train tickets are usually only valid for a short period in time, we can get into our car whenever we want and drive any route that comes to our mind. Traffic jams, detours, or temporary road blocks apply to every driver the same way. And also speed limits or priority are not depending on how much we pay. This also holds true for toll that might be charged to cross a bridge or a tunnel – every driver is treated the same way.

However can we take this condition for granted that provides a network of roads in a neutral way to every user? Net neutrality is not a matter of fact in every industry, not even in all branches of mobility and logistics. Rail services e.g. charge special rates for express trains. While the tariff structure of rail companies are rather transparent in passenger services, this is not the case for transportation of goods. Depending on the buying power and on the negotiations of the customers‘ procurement, freight will be transported timely or might travel rather slowly to its destination.

In telecommunications, the rate structure is even more notorious for its lack of transparency. Voice and data plans vary by orders of magnitude regarding bandwidth or duration that comes with different plans.

Net neutrality in telecom services became an important issue when ‚over the top services‘ like Youtube or Netflix started to consume significant proportions of bandwidths. It became obvious that in the long run the carriers would be degraded to mere suppliers of infrastructure, just delivering a commodity instead of becoming ‚value added services‘ that could charge their customers extra for their precious entertainment programs.

Until now, users pay for using the service in terms of just transportation of the data packages, no matter whats in the date. Since they are the ones who pay, it should thus follow consequently that the services they want to access must not be charged by the telcos or otherwise the service would be charged twice. In Europa as in many parts of the world it is still mandatory for telcos to act neutrally regarding the services requested by the users.

‚Managed services‘ is what telcos are lobbying for in opposition to net neutrality. The argument goes that companies like Google (with Youtube in particular) or Facebook act like parasites on the infrastructure – skimming the profits without contributing to maintain it. Although there is very little facts provided to prove the allegations, it is not totally implausible. Advocates for net neutrality would respond though, that restricting net neutrality would give telcos a wrong incentive, not to invest in infrastructure to improve the situation, instead to shorten supply to be able to raise the price for services, or even worse, to exclude competition like Skype or Whatsapp and rather continue selling their own products like voice telephony or SMS.

With roads, the situation is fundamentally different. It is comparably easy to add new wires or build additional base transceiver stations to get more throughput for the network. It is much harder to build more roads, in urban environments it is often even impossible to increase the capacity for traffic. The consequence can be seen everyday: Traffic jams, overcrowded parking lots, polluted air. Worst examples are the big metropolitan centers in China and India, but the situation in most big cities in the US is also dire.

Road access without regulations thus leads to a classic example of the ‚tragedy of the commons‘. Each driver will ask herself, why she should be the one to refrain from the benefits of individual traffic and switch to public transport. Some cities have already introduced special tolls, like the congestion fee for entering central London.

Autonomous cars and car sharing services when becoming broadly available would indeed offer another model. Telecommunication carriers license frequencies in the electromagnetic spectrum from the state, for which they have to pay a considerable sum. In return they can offer differentiated rate plans to their customers, and realizing a significant upside for themselves. Cities or whole countries could offer mobility carriers a similar deal: Car sharing platforms would rent capacity from the public, and resell their added value mobility service to finance the infrastructure. Rate plans could be fine tuned and automatically adapt demand. It might in this way just become to expensive to use individual means of transport for a commute that you could as well do in public transport or by bicycle.

That this is no far fetched business model at all is shown by Uber. Uber’s surge pricing anticipates such mobility services reacting elastically to actual demand. A major outcry followed when people became aware that instead of being charged a few dollars like usually, they would suddenly face payments more expensive by orders of magnitude.

Since the times of Henry Ford, individual traffic in the own car has been woven into the culture of most societies. It is thus not easy see opportunities and risks from a more distanced, more objective vantage. It will also not be easy to find the right rules and regulations to make a system of managed services for mobility fair and supportive to the economy.

The worst would be a contemporary version of highwaymen. Second worse however would be to go on and waste space, pollute the air, and jam the vessels of urban life like it can be seen in many cities today. Net neutrality for mobility will therefore become an important issue.

New Product Development in the Age of IoT

If you’re responsible for new product development in your company, you will be familiar with the several steps of that process. Experts mostly separate the new product development process into seven or eight steps, starting with idea generation and finishing with a post launch review. The fact that more and more things become smart; i.e. they either feature some intelligence or they are connected and controlled through the IoT, has significant implications on new product development, particularly on its very first phases.

Traditionally, ideation and screening of first product ideas have focused on research, brainstorming, SWOT analysis, market and consumer trends, and so forth. All these activities imply certain hypotheses and more or less tangible perceptions of products or product components. This works fine, as long as the final product is a one-way product; i.e. once produced and sold it won’t change (other than to age and break, ultimately). However, smart things aren’t on-directional, but bi-directional: they communicate, they change, and therefore their effects on consumers are far more complex and variable than those of their „dumb“ predecessors.

The smarter a thing, or a group of things, is, the more complex the situations they will create for their environment and their users. The much discussed self-driving cars which algorithms must decide whom to run over in case of an inevitable accoident provide a good example of the complexity future products will create.

Now – what are the implications of smarr things and the IoT on new product development? The answer is pretty easy – we just have to look at the discussions regarding the IoT: privacy, responsibility, sustainability, awareness, acceptance, relevance, and ethics. Is my data secure? Who takes responsibility of data provenance? Do I want this thing to be smart? Do I accept a thing’s decision? Do things add value? Do others accept me using my smart thing? Can I defend using my smart thing against my beliefs?

We can sort these crtical questions into three categories:

  • – philosophy (ethical aspects),
  • – sociology (responsibility/acceptance aspects) and
  • – psychology (awareness/relevance aspects).

Philosophy, sociology and psychology are the „new“ fields for benchmarking new product ideas. As distinct from present techniques of finding new product ideas, corporate innovation managers will have to broaden their scopes and companies will have to adapt by hiring and training their innovation departments towards these fields of expertise. Today, only very few companies seem to have inherited this new way of thinking: just look at how Apple creates and markets its products: there is no talk of product features, but of sustainable production chains, of family accounts or enhanced well-being.

Would you have thought that philosophy, sociology and psychology would play a pivotal role in new product development? Could that mean that philosophers sleeping in ceramic jars now can afford posh apartements, or formerly unemployed sociologists can choose their employers, or psychologists leave their universities to actually develop new products? And – will we see a lot mote useful, meaningful, usable and accepted products? I think so.

Know And Speak To Your Customer Through The IoT

Equipped with sensors and microchips, ever more of objects can communicate, with each other and with human beings – the Internet of Things and Humans is born. Even washing powder is set to become smart through attached sensors on its packaging that detects when the product is being used, and that communicates with readers like smartphones when scanned. From today’s 5 billion to 21 billion by 2020, the number of wirelessly connected things will increase. 

Who will profit from the Internet of Things – or IoT – most?
Let’s look at the obvious applications, first: Stock-keeping and supply-chain management processes will have implemented technologies making objects communicating with each other, thus enabling businesses to follow the progress of their products from factories to shops to end-consumers. Espresso beans will tell baristas about the best temperature to keep them in stock. Batteries will inform their owners when reaching the last phase of their power-providing lives.
From our perspective, however, the biggest potential lies in customer relations. Brands are realizing that the best way to sell their products is to build personal relations with customers rather than to spend lavishly on marketing. Until today, many brands come only second behind retailers with regards to communication to their customers. Often, it’s the retailer who knows the customers‘ preferences best, and who is able to retain them through loyalty schemes. Ask yourself: where do you buy your stuff? Online retailers are the ones understanding their customers best, often they have the complete customer journey available.

Speak to your customer
Now it becomes cheaper to add sensors and microchips to products, and to connect them to the internet. The direct result of the IoT is a huge influx of customer or end-user data. Whereas nobody at manufacturers and brands had to – or better: was able to – gather data of actual customer behavior so far, there now arrives Big Data describing everything these companies have ever wanted to know. In theory, this data will help them develop their products and services more rapidly, fix any bugs more quickly and tailor products better to their end-users‘ needs.

In practice, the gigantic flood of data may imply significant structural changes for manufacturers: is the IT infrastructure set to cope with Big Data? Is the IT personnel eqipped with the necessary knowledge amd experience to handle data sampling and dara storage correctly? Are there adequate in-house resources to munge and analyze the data? And, after all, will anybody visualize and instrumentalize the data in a meaningful way? Sure, there already are best practices regarding individual steps of this Big Data process. And for each part of the process, there are tools that can be used a software-as-a-service. But it`s a long way from data sampling to a smoothly managed customer relation through objects.

A new era of competition
Managing and optimizing the company’s own customer relations through the IoT is just one part of the equation: when retailers start a direct communication with their end-users, retailers won’t passively stand on the sidelines. They will fight back trying to defend their position of being „first-to-the-customer‘. And on the operative level, retailers have a big advantage: they have always been the ones with a direct contact to the customer. They know their customers (or at least they should). Everybody who switched from working in a company without direct contact to the customer to an end-user shop has experienced a cultural clash: you won’t imagine the expectations of a typical end-user – i.e. ourselves. Let alone all additional privacy and cyber-security issues.

That said, the IoT offers manufacturers the biggest opportunity since the industrialization. They can understand and learn from their customers. They can even partner with them. But first they have to do their homework and provide all the needed resources in IT infrastructure, processes, and human resources.