The General Data Protection Regulation (GDPR)

The General Data Protection Regulation (GDPR) is a European Regulation that focuses on data protection and privacy for all individuals in the European Union, which goes into effect on friday May 25th, 2018. This regulation applies to all companies based in the European Union, but also any companies that processes data belonging to the EU citizens.

As such this regulation applies to Structum, the parent company of iKnode. We have many users which are European Citizens and this fact makes this regulation extremely important to us. At its most basic form the GDPR specifies how personal data should be collected, stored, protected and used. It is intended to put personal information control back in the hands of their owners.

We are committed to protecting and safeguarding your personal data and as part of this commitment, we have updated our Privacy Policy in preparation of the GDPR legislation. Due to the nature of our service, the iKnode family of services do not require changes to be GDPR compliant. There are no changes to the current settings of your account or how your information is processed.

The GDPR introduces the following user rights and how they are addressed:

• Customers can easily request access to their personal information.

  Request your personal information here.

• Customers can easily update their personal information to keep it up to that.

  All users can change their personal information using the iKnode Web Console, by clicking their name in the top right corner.

• Customer’s data can easily be removed once the information is no longer necessary.

  We have a removal policy of 30 days after a customer has cancelled their account with us.

• Customers can request the deletion of their data.

  Customers can request the deletion of their data before the 30 days policy is reached by requesting deletion here.

• Customers can easily request that their data be delivered to themselves or a third party.

  Request your personal information here.

There are 2 roles considered by the GDPR:

• Data Processor - Processes and Stores the data collected.
• Data Controller - Determines what and why data is collected.

Structum’s role when it refers to the iKnode family of services is a Data Processor. Developers hosting their apps on the iKnode Cloud are a Data Controller. Please review the GDPR Checklist to make sure you are GDPR compliant.

In order to help iKnode developers, we have added a data export feature that will allow you to extract data easily from iKnode to comply with your users right to request their information.

Query Console Export

As you can see in the picture above you can type a query on an specific collection and export the results as pure JSON, either by copying it to the clipboard, or by exporting it to a file.

This feature will come in handy when a user of your application requests the data you have collected. You can query by an specific user identifier, and export the data as JSON.

Data Storage Export

The other way to export your data is by exporting the full collection into JSON. This feature will come in handy if you store all of the data for a user or tenant in a collection. By clicking the “Export All” you will get a file with all of the documents in the collection.

If you have any questions and/or concerns regarding privacy, please do not hestiate to contact us at: privacy@structum.net

To learn more about the GDPR please visit the following sites:

• General Data Protection Regulation
• The GDPR check list
• GDPR Shield

This bug affects OpenSSL only and specifically versions 1.0.1f, 1.0.1e, 1.0.1d, 1.0.1c, 1.0.1b, 1.0.1a, 1.0.1 and it is currently patched in version 1.0.1g.

Our infrastructure has some nodes that use Linux but they are not exposed to the web, and do not contain our SSL certificates. Even so, we do use Rackspace’s and Amazon’s Load Balancers which as it turns out are vulnerable. Interestingly enough when we first setup our infrastructure we decided to host our certificates in our web server images, instead of using the SSL termination in the load balancer. Since our web application is .Net based it is also hosted on Windows on IIS. This means that we are not vulnerable at all.

We planned to move our certificates to the Load Balancer in order to ease our image deployments. After this event, we are rethinking that strategy. It is interesting that we were unaffected by this by pure luck, since we were in the process of moving our infrastructure to a new engine (which we will talk more about later), we were also configuring SSL termination in the load balancer.

As of right now, you have nothing to worry about while using iKnode. We are not affected bythis bug at all. It is still recommended that you change your password for iKnode Management console.

If you want to check other sites to see if they are vulnerable to the bug, you can use any of the following:

• Heartbleed test (filipo.io)
• LastPass Heartbleed test (lastpass.com)

It seems that our great friends at Cloudflare have identified that this bug doesn’t leak the private key. We’ll keep you updated as more information is revealed.

If you have any questions or concerns, please don’t hesitate to contact us. We can be reached by using the Support console.

WeTheAdorned is a members-only online jewelry platform which is curated by the famous “Sex And the City” star, Sarah Jessica Parker. This exclusive platform will allow T.Cyia’s bold designs to reach other parts of the world first hand and interface directly with the consumer, and it will also empower the subscriber to be able to acquire the stunning jewerly that was only available to Hollywood stars. For iKnode, this project allowed us once more to create seamless technology that powers creativity while placing the focus on the product and not the technology itself.

We were tasked with designing a launch page to measure interest, first by allowing people to subscribe to the newsletter and second by allowing people to signup for the service for a reduced price during launch. We chose HTML5 and Bootstrap for the front-end, and iKnode as the backend.

We built two applications: 1) One that manages the Newsletter subscriptions, and 2) one that manages the payments. For the Newsletter subscriptions we used the iKnode Package for MailChimp. We created a newsletter using MailChimp’s intuitive deisgner, and sent user subscriptions from the landing page all the way to mailchimp. In the case of payments we used the Stripe iKnode Package to signup and charge users for the service without us even worrying about storing credit card information on our servers or worrying aobut PCI compliance.

Using iKnode was not only a time saver in terms of development and maintenance, it was also an amazing platform for reliability and stability by handling high traffic peaks without being noticed. The iKnode cloud was able to handle approximately 10,000 requests per second on the highest traffic day.

We are very lucky to be able to work with Tim & Cyia in such a bold project. We are excited to see what is yet to come from this amazing duo and how technology will power one of the most creative profession of the world.

The new design is clean and very well structured:

With this new design we strived to improve the usability and structure to make it easier to navigate and read. The navigation was one of the most important improvements we added. Before it was just a simple Octopress menu, now it is a minimal but powerful side bar.

The content is also less cluttered, now that it is divided into several pages, instead of having only one page for all. At the beginning, we thought having it all in one page would be easier for the user and for us to read and look for, but as it grew, it became too much. Multiple pages encapsulates the content better and it also helps you focus on what you are trying to learn.

Go check the documentation site yourself and let us know what you think.

iKnode Documentation

Before API v3, the parameters had to be passed to the SDK using a Dictionary-like structure like this:

1
2
3
4
5
6
7
8
9
10
11
12
13

var helloWorldSvc = new iKnodeSdk.ApplicationClient({
    userId: USERID,
    apiKey: APIKEY,
    appName: "HelloWorld"
});

var response = helloWorldSvc.execute({
    methodName: "HelloYou",
    parameters: [{
        name: "yourName",
        value: "John Doe"
    }]
});

Now you can do this:

1
2
3
4
5
6
7
8
9
10
11
12

var helloWorldSvc = new iKnodeSdk.ApplicationClient({
    userId: USERID,
    apiKey: APIKEY,
    appName: "HelloWorld"
});

var response = helloWorldSvc.execute({
    methodName: "HelloYou",
    parameters: {
        yourName: "John Doe"
    }]
});

Instead of passing the parameters as a Key-Value pair, you just pass the parameter in a common JSON object format. It is way more javascript friendly, and API friendly as well. No need to format the parameters in weird ways, and no need for the parameter formatting used before.

The latest Javascript SDK is backward compatible, but in order for the SDK to work with Key-Value pair parameters, just add the following flag:

1
2
3
4
5
6
7
8

var response = helloWorldSvc.execute({
    methodName: "HelloYou",
    formatParameters: true,
    parameters: [{
        name: "yourName",
        value: "John Doe"
    }]
});

Let us know waht you think.

Version 2 of the API worked perfectly fine, but it wasn’t as simple as it could be. The POST body needed to be wrapped in a JSON object which only contained one field: “parameters”. This made the API calls cumbersome for complex objects. Escaping had to be done, since the parameters field expected an escaped json formatted string.

For example, calling and application method “HelloYou” form the application “HelloWorld” requiring one parameter, would need to be called like this in version 2:

1
2
3
4
5
6

curl -X POST \
-H "iKnode-UserId: [YOUR-USERID]" \
-H "iKnode-ApiKey: [YOUR-APIKEY]" \
-H "Content-Type: application/json" \
-d '{ "parameters" : "{ yourName: \"John Doe\" }" }' \
https://api.iknode.com/Applications/execute/HelloWorld/HelloYou

Notice how the parameters are wrapped and escaped in the POST body: ’{ “parameters” : “{ yourName: "John Doe" }” }’

With the new API, the POST body contains your JSON object exactly as you serialized. No need for escaping or encoding. Additionally, the User Identifier is now part of the URL, only the API Key needs to be added in the header.

1
2
3
4
5

curl -X POST \
-H "iKnode-ApiKey: [YOUR-APIKEY]" \
-H "Content-Type: application/json" \
-d '{ "yourName": "John Doe" }' \
https://api.iknode.com/v3/[YOUR-USERID]/HelloWorld/HelloYou

Notice the parameters are no longer wrapped, and the JSON parameter is represented as is: { “yourName”: “John Doe” }

Needles to say, that if you are using the SDK, this change doesn’t change anything in your code. The newesst SDKs already support Version 3 of the API. Just upgrade to the latest version of the SDK and you are set to go. No need to change your code.

For more information check the documentation here.

We coded for days and nights to realize the vision. To create every single building block that made the iKnode cloud. Learning from our beta users, and our testing. We were 3 at the time. With Joel doing the Graphics and the fron-end, Jorge and me working on the engine.

We saw Backend as a Service providers pop up from everywhere. It seemed like the market started to get full of competitors, and that made us feel excited, empowered even. It validate our idea, but most importantly it validated our dream. We welcomed the competition enriching the market and make it more fun.

Around May 2012, we noticed more BaaS providers started to popup. A lot of them were companies that seemed to be cloning other BaaS providers features, and most of them didn’t bring anything new to the table. The competition started to get boring.

Nothing interesting was coming out, except for one company: Spire.io. We glanced through their site, and saw a spark of new, but something about them seemed very familiar. Their passion, it seems, was the same as ours: making developers life easier by creating a serverless world. The best way to make distributed computing easy, is to remove servers. We felt the competition was getting too close this time. For a moment we were afraid, but also happy. We were not alone.

We kept a close eye on them for the following months and then dozed back in to our own product and our own vision. We began to ramp up development to release at the DEMO conference in October. With Sophie’s help, and an amazing design by Joel, we invested in T-Shirts, Stickers and swag. We were proud to wear and iKnode T-Shirt, we still are.

October (2012) came and we launched iKnode at DEMO. We were a great success, attracting a big number of users into our dream cloud. Sophie joined to run the business, which was just starting. The following months after that we kept the feedback loop active learning and learning from our users.

By December 2012, I was able to get back to market analysis. Moving away a bit from our own user base to the information on the web. The first thing my list was to check on Spire.io. I was afraid to find them ahead of us. After all we were the only providers going after the web in the same way.

So I typed on my chrome instance: spire.io….. Nothing. The site was down. I thought. It seemed crazy that a Cloud provider would allow their site to go down. So I tried again. And again I got Nothing. I checked www.downforeveryoneorjustme.com, and validated. Their site was down. Completly down. What happenned ?

I began to tirelessly look for news around the web regarding Spire.io, to see if there were any press releases, blog post, etc. Checked Hacker News first, then Reddit, then Tech Crunch, and every other imaginable tech news site. Got Nothing. Nada.

I was perplexed. I was scared even. How can a company disappear over night? I began to be very scared. What happens if our dream is wrong ? What happens if what we are looking for is unattainable ? The team at Spire.io had the answer and I had to find out.

I first sent a tweet to the @spireio account:

@spireio Hey guys we are in Orange County, and building a BaaS (@iknode) as well. We should get together to talk BaaS :D

— Alex Espinoza (@alespinoza) December 4, 2012

The CEO responded:

@alespinoza @spireio @iknode hi Alex, unfortunately, we had to wind down spire. But thank you very much for reaching out.

— Diego Prats (@mexitlan) December 4, 2012

He was very nice, but still I needed to know more, so I insisted.

@mexitlan @spireio @iknode I would still love to talk to you, if you are interested. I would love to hear what went wrong.

— Alex Espinoza (@alespinoza) December 4, 2012

To make the story short, he contacted me over email, and we were able to talk over the phone for an hour or so. Several interesting things happened during that phone call. Not only did we had the same dream to make a serverless world, but also he is from Mexico, just like us. And he lives in LA, which is pretty close to us; we are in Orange County. I thought that was amazing. And it seemed to me to be a cosmical connection.

After I hanged up, I felt relieved to know that our dream was still attainable. Additionally I made a friend, which shares our dream. I was a happy camper.

In the following months Diego, began helping more and more to pave the way for iKnode. For the iKnode team, Diego seemed part of it already, so we decided to officially invite him to be part of the iKnode family.

Today, we are proud to announce, Diego Prats joins the iKnode team as Chief Strategy Officer. His experience and expertise is first rate in the Backend as a Service industry. He will be mainly helping to build the dream on solid ground with a real solid business framework that will hold iKnode’s feet in the ground, but keep the heart flying in the serverless clouds.

And now with a complete team, in the words of Buzz Light Year:

Packages are prebuilt themselves are applications, and as such can be executed from the dashboard, directly from the API or from inside your application just like any other iKnode application. The same properties that apply to custom applications apply to packages with the only difference is that packages are not editable. “Packages” is inspired by the spirit of NuGet and apt-get. The idea is to allow the installation applications that are already built and that you can start using by just the click of a button.

Installation

To install a package, just go to the packages section and clik the “Install” button for the package you want to install. The package will be installed and it will appear in the Dashboard with the “.App” postfix. If for example, you were to install the Twitter package you would see “Twitter.App” in your dashboard. You would not see it in the Apps section though, due to the fact that packages are not editable.

If you decide you don’t want to use the package anymore, just go to the Packages section, click the “Installed Packages” button. The list of Installed packages will be displayed. Just click the Remove button for the package you want to remove and the package will be removed.

Configuration

Some package require configuration, like the Emailer. The emailer is used to send emails using an external email server like Gmail. You can configure the package by using the CreateConfig Package.

This method in the Emailer App creates a record in the AppConfig collection in the Data section. You can change the configuration at anytime by just going to the AppConfig collection and edit the selected item.

Social Packages

The Social Packages like Facebook or Twitter require OAuth as an authentication mechanism to do anything useful. For that we created the Social Connector. The main purpose of the social connector is guide you through the OAuth process so that you can integrate with Twitter and Facebook without you having to do any coding whatsoever.

To use the social connector simply go to the apps section, and click on the Social Connector button.

You will then get a tab that shows the Connectors that we have. Currently we only support Twitter and Facebook, but more are on the way. Just select the Service you want to connect to (Facebook or Twitter) and the Social Connector will guide you through the process.

Once the process is done, the OAuth credentials will be stored in the SocialMedia collection.

Available Packages

• Emailer: Send emails using your own Emailer Server.
• Facebook: Post messages to your facebook timeline.
• FTP: Upload and Download Text Files using your own FTP Server.
• Logger: Log Errors and Events with this application.
• Site Monitor: Application that helps you Keep track of your site by checking the status of your http/https site or your net.tcp services.
• Twitter: Post messages to your twitter timeline.

In future releases we will be upgrading the current packages and adding new ones. If you have a package that you wish to see implemented, drop us a line, we will gladly consider it.

For more information go to: Packages Documentation.

The Login Page

The first thing we tackled was the login. We felt the login seems old and resembled a Desktop application. The login is important, because this is the first thing you see when you log into iKnode. It had to be cleaner and attractive. So we remove most of the text, focused on making the login screen more iconic and easier to understand.

Instead of having the word “Email :” next to the email field we added an email icon, and next to the password field a lock. By removing the field labels the login screen automatically looked more pleasing and inviting, so we knew we were going in the right direction. We also simplified the welcome message. Nobody really reads it or pays attention to it, so we made it more functional; instead of a welcome message we replaced it with “Login or Create a new Account”.

Before you could only create an account from the main site, but we noticed that some tried to create an account directly from the login, so we added the link to the login.

The Sidebar

The second thing we focused our attention to was the ever growing sidebar. It had too many options and only a handful of options were really being used. But the biggest problem was that the sidebar didn’t make it clear what features were offered. Too many choices, and not a clear part on where to start.

With the new sidebar we make clear that we have 3 main features: Backend Apps, Data Storage and Scheduling. The order is also set to let the user know where to start. The first thing to do in iKnode is create an App. Then create Data Stores and if needed Schedule some apps to run at a specified period in time.

The new sidebar also improves the usage for mobile devices where screens are smaller. For this iteration we focused completly on tablets like the iPad, Nexus 7 and the Surface RT. The sidebar buttons are now big enough for a very precise finger button click, when before you usually needed to zoom in.

Additionally we removed the “Feedback & Support” floating tab and added it to the sidebar. This decision was made to unify the design, the tab always looked out of place. With the Support button as part of the sidebar it feels more accessible and consistent.

The Topbar

The third place we focused our attention to was the top bar. This top bar has changed considerably since iKnode started. In this time, we made the top bar a kindda scoreboard. We had the metrics on the dashboard before, but nobody really saw them, because most users spent their time coding in the editor. So we moved the stats to the top where they are visible no matter where you are in the site.

The Application List

The fourth item we decided to improve was the Application List. The application list used to look like a small desktop grid, which made usage in tablets very complicated because of the size of each row. What we decided to do was make the grid line higher and wider, with big buttons at the end. It still needs improvement, but the this is a start. We also added the Application icon to make applications easier to identify.

The Editor

The fifth place and one of the most important ones is the editor. We have been working tirelessly to make the editor more usable. We are using ACE and for sometime we used a really old version of it. In the past month Jorge decided to put some love into the editor integrating the latest version of ACE and adding some well deserved keyboard bindings. It was frustrating to save an app by cliking the button. I usually save my code everytime I finish a line, which means that my development time was impacted considerably.

So in the editor, we first focused on making the code editor itself larger, so that we can focus on the code. The references and Properties that were part an editor sidebar were only used around 5% of the time, where the editor was used approximately 95% of the time. Additionally I am an avid Emacs user, and I love the simplicity of the editor with no toolbar, sidebar or anything else.

In order to achieve what a lot of developers call the “Zen Mode” we had to allow the editor to take the rest of the screen. So we moved the References and Properties tabs out of the way. We created a tab for the editor, one for the references and one for the properties. This made a hell of a difference. It feels like Emacs, and I love it.

We also changed the icons. We felt the Disk icon, which reprented the save process, was outdated. I think the Disk is no longer the best way to represent the save operation, so we changed to a Server Save icon.

This UI improvement experience was amazing. We had been so focused on pumping up our infrastructure that we overlooked the user interface. We put a lot of heart and love into iKnode, most of the time it can’t be seen with the naked eye, but in this case, it is out there for everybody to enjoy.

Please let use know your thoughts about the new changes.

One of the major changes is the upgrade of the application editor, this will allow us to extend the editor functionality and features plus the improvements and fixes that come with the upgrade, e.g. you’ll notice you are now able to collapse or expand code blocks.

So as a start we’ve added some key shortcuts for what we consider the most common operations when using the editor, we are talking about saving, compiling and publishing your apps, so here are the key shortcuts you may use when using the editor, for PC and MAC:

• Save (Ctrl+S, Command+S).
• Compile (Ctrl+Alt+B, Command+Alt+B).
• Publish (Ctrl+Alt+P, Command+Alt+P).

As I mentioned, this is just the beginning, we are planning to add more features that make the editor better and easier to use, as an example:

• Toggle comments blocks.
• Indent code regions.
• Search and replace.

Your comments and suggestions are of course more than welcome. More things are on the way, so stay tuned.

Happy Coding!

The SDKs are built with the purpose of making it easier to access your API through the REST interface. It is not required for you to learn how to use the SDKs at all. Our REST API is very friendly as well, but we do recommend using it; it makes it so much easier.

The SDK follows exactly the same philosophy for all platforms. This means that if you know how to use the Javascript SDK or the C# SDK, the iOS SDK will be a piece of cake.

For this example we are going to use the following API:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

using System;
using iKnode.Applications;
using iKnodeSdk.UnitTest.Domain;

namespace iKnodeSdkTest
{
  /// <summary>
  /// Defines the User Service.
  /// </summary>
  [Application]
  public class UserService
  {
        /// <summary>
        /// Gets the User First Name by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User First Name/.</returns>
        public string GetFirstNameById(int id)
        {
            return "Robert";
        }

        /// <summary>
        /// Gets the Most Common User First Name.
        /// </summary>
        /// <returns>Most Common User First Name/.</returns>
        public string GetMostCommonFirstName()
        {
            return "John";
        }

        /// <summary>
        /// Gets the User by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User Information.</returns>
        public User GetById(int id)
        {
            if(id != 1) {
                return null;
            }

            return new User(1, new FullName("John", "Doe"));
        }

        /// <summary>
        /// Saves the User Information.
        /// </summary>
        /// <param name="user">User Information.</param>
        /// <returns>User Identifier.</returns>
        public int Save(User user)
        {
            if(user == null) {
                return -1;
            }

            //TODO: Here your store the User Information.

            return user.Id;
        }

        /// <summary>
        /// Creates a new User with the Default Information.
        /// </summary>
        /// <returns>User Information.</returns>        
        public User CreateDefault()
        {
            return new User(2, new FullName("Jane", "Doe"));
        }

        /// <summary>
        /// Creates a new User.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        /// <returns>User Information.</returns>        
        public User Create(int id, FullName name)
        {
            return new User(id, name);
        }
  }
}

The model used by the iKnode Application is the following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

namespace iKnodeSdkTest
{
    /// <summary>
    /// Defines the Full Name class.
    /// </summary>
    [Serializable]
    public class FullName
    {
        /// <summary>
        /// First Name.
        /// </summary>
        public string FirstName;

        /// <summary>
        /// Last Name.
        /// </summary>
        public string LastName;

        /// <summary>
        /// Initializes a new instance of the <see cref="FullName"/> class.
        /// </summary>
        /// <param name="firstName">First Name/</param>
        /// <param name="lastName">Last Name.</param>
        public FullName(string firstName, string lastName)
        {
            this.FirstName = firstName;
            this.LastName = lastName;
        }
    }

    /// <summary>
    /// Defines the User class.
    /// </summary>
    [Serializable]
    public class User
    {
        /// <summary>
        /// Identifier.
        /// </summary>
        public int Id;

        /// <summary>
        /// Full Name.
        /// </summary>
        public FullName Name;

        /// <summary>
        /// Initializes a new instance of the <see cref="User"/> class.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        public User(int id, FullName name)
        {
            this.Id = id;
            this.Name = name;
        }
    }
}

This API is the same used to demostrate the usage with the Javascript and C# SDKs.

Using just the REST endpoint we would call this API in the following way:

1
2
3
4
5
6

curl -X POST \
-H "iKnode-UserId: [YOUR-USERID]" \
-H "iKnode-ApiKey: [YOUR-APIKEY]" \
-H "Content-Type: application/json" \
-d '{ "parameters" : "{ id: \"1\" }" }' \
https://api.iknode.com/Applications/execute/UserSvc/GetById

In the iOS SDK the return type is usually NSDictionary for complex objects as seen in the following example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

ApplicationClient *client = [[ApplicationClient alloc] initWithServiceUrl:BaseUrl
                                                              AndUserId:UserId
                                                                AndApiKey:ApiKey
                                                               AndAppName:@"UserService"];

NSDictionary *params = [NSDictionary dictionaryWithObject:@"1" forKey:@"id"];
NSData *data = [client ExecuteWithMethodName:@"GetById" AndParameters:params];

NSDictionary *user = (NSDictionary *) data;

// User Id
user["Id"];

// User Full Name
user["FullName"];

Hope you find it useful. This SDK, as well as all the others are open source and can be found in here. You can use them as you wish.

We decided to submit our own app to the Chrome Web Store so it’ll be easier for the iKnode developers to access iKnode, now just a click away ;) for Google Chrome lovers, so just search for “iknode” on Web Store or click here to go directly to it.

We are working really hard to improve the iKnode experience, enjoy.

You can install the SDK for your projects using:

1

PM> Install-Package iKnodeSdk

Don’t forget that you can always get the latest source code and binary releases directly from our Github Page. If you want to download the latest version of the SDK without using NuGet, you can do so by going to the Downloads Section in Github.

Happy Coding!!!

In this spooky day, we wish everybody a Happy Halloween!!! We are getting our costumes set, and our bags are ready to be filled with a lot of candy.

By the way, the halloween icons used in this site are courtesy of RocketTheme Halloween Icon Pack 1 by RocketTheme - http://www.rockettheme.com.

There are frameworks that make it easier, but even after you reduce the complexity by adding a library to handle Web Requests, parsing adds to the problem. Thinking about these two problem we designed an SDK for iKnode Applications that makes it extremely simple to execute from your client.

First, by handling ALL Web Requests without your client having to know about the security or how to do POST requests. Second it parses the results as as native C# classes or Javascript objects.

One very important aspect of the new SDK, is that you learn it once in any language, and you learn it for the rest. Right now we are only supporting C# and Javascript, but the Android and iOS SDKs are on the way and will be handled in the same way, focused completly on consitency.

It’s time to look at some code. Let’s say that we are building a User Service which is used to manage User information in the cloud:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

using System;
using iKnode.Applications;
using iKnodeSdk.UnitTest.Domain;

namespace iKnodeSdkTest
{
    /// <summary>
    /// Defines the User Service.
    /// </summary>
 [Application]
  public class UserService
  {
        /// <summary>
        /// Gets the User First Name by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User First Name/.</returns>
        public string GetFirstNameById(int id)
        {
            return "Robert";
        }

        /// <summary>
        /// Gets the Most Common User First Name.
        /// </summary>
        /// <returns>Most Common User First Name/.</returns>
        public string GetMostCommonFirstName()
        {
            return "John";
        }

        /// <summary>
        /// Gets the User by its identifier.
        /// </summary>
        /// <param name="id">User Identifier.</param>
        /// <returns>User Information.</returns>
        public User GetById(int id)
        {
            if(id != 1) {
                return null;
            }

            return new User(1, new FullName("John", "Doe"));
        }

        /// <summary>
        /// Saves the User Information.
        /// </summary>
        /// <param name="user">User Information.</param>
        /// <returns>User Identifier.</returns>
        public int Save(User user)
        {
            if(user == null) {
                return -1;
            }

            //TODO: Here your store the User Information.

            return user.Id;
        }

        /// <summary>
        /// Creates a new User with the Default Information.
        /// </summary>
        /// <returns>User Information.</returns>        
        public User CreateDefault()
        {
            return new User(2, new FullName("Jane", "Doe"));
        }

        /// <summary>
        /// Creates a new User.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        /// <returns>User Information.</returns>        
        public User Create(int id, FullName name)
        {
            return new User(id, name);
        }
  }
}

In this case we are going to have the following classes as part of the model to be shared by the service and the C# client. For the Javascript client the model is not required.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

namespace iKnodeSdkTest
{
    /// <summary>
    /// Defines the Full Name class.
    /// </summary>
    [Serializable]
    public class FullName
    {
        /// <summary>
        /// First Name.
        /// </summary>
        public string FirstName;

        /// <summary>
        /// Last Name.
        /// </summary>
        public string LastName;

        /// <summary>
        /// Initializes a new instance of the <see cref="FullName"/> class.
        /// </summary>
        /// <param name="firstName">First Name/</param>
        /// <param name="lastName">Last Name.</param>
        public FullName(string firstName, string lastName)
        {
            this.FirstName = firstName;
            this.LastName = lastName;
        }
    }

    /// <summary>
    /// Defines the User class.
    /// </summary>
    [Serializable]
    public class User
    {
        /// <summary>
        /// Identifier.
        /// </summary>
        public int Id;

        /// <summary>
        /// Full Name.
        /// </summary>
        public FullName Name;

        /// <summary>
        /// Initializes a new instance of the <see cref="User"/> class.
        /// </summary>
        /// <param name="id">Identifier.</param>
        /// <param name="name">Name.</param>
        public User(int id, FullName name)
        {
            this.Id = id;
            this.Name = name;
        }
    }
}

Now in the C# client side, you would call the UserService in the following way:

1
2
3
4
5
6
7
8
9
10
11

// Creating User Id 1 with Name jdoe.
ApplicationClient userSvc = new ApplicationClient(
                        "https://api.iknode.com",
                        UserId,
                        ApiKey,
                        "UserService");

User user = userSvc.Execute<User>(
                      "Create",
                      new MethodParameter("id", 1),
                      new MethodParameter("name", "jdoe"));

Now in Javascript the same call would look like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

   var userSvc = new iKnodeSdk.ApplicationClient({
      userId: USERID,
      apiKey: APIKEY,
      appName: "UserService"
  });

  var user = userSvc.execute({
      methodName: "Create",
      parameters: [{
              name: "id",
              value: 1
          },{
              name: "name",
              value: "jdoe"
          }
      ]
  });

It is as simple as that. The source code for the SDK can be found here. Each platform SDK has a set of Unit Tests that show how the SDK can be used.

If you have any questions don’t hesitate to ask questions in the forums.

We want to thank our Beta users, we really appreciate your feedback. All your data and applications will still be there, and you will get the rest of the year free.

Finally We also want to thank Microsoft for sponsoring us to launch at DEMO. We have been working with Microsoft’s technologies for the past 10 years, and we are proud to be part of the Bizspark program.

And with no further ado, here are some pictures of the event:

Our Badges:

Beautifully created flyer for DEMO:

iKnode Signage:

iKnode kiosk’s next to Windows 8 Kiosk:

Sophie at the Kiosk:

Alex at the Kiosk:

Introducing Icons in the Dashboard

Applications can now have their own icon for the Dashboard. This will make it easy to find apps in the dashboard, while also making it beautiful. Choose from 152 beautifully crafted icons by IconDock.

In order to set an icon for your app, all you have to do is go to the properties tab of your applicaiton and select an icon. By default all applicaitons have the ‘window’ icon set. You can change it easily by selecting the icon that best identifies your app from the list of available icons.

Improved JSON Viewer for the Query Console.

The Query console is now friendlier by displaying the JSON results with a fresh JSON viewer. The JSON viewer makes it easier to browse through the results of your query by allowing the object collapse and expand, and you can still select, copy and paste to anotehr screen. So it pvodies the ability to browse JSON objects without loosing the flexibility of text results.

We had been using the default theme which defaults to the Monaco font (if you have it) on the editor. The problem is that the Monaco Font is created for a font rendering scheme that focuses on the shape of the font which looks blurry sometimtes like the Mac OS. But when you are developing in windows, Monaco looks too blurry, because Windows rendering algorithm forces the font into pixels. So we decided to put Consolas first (which looks amazing on Windows Systems) and then Monaco (which looks amazing in *nix and Mac).

We also decided to change the colors to match the site colors, and preferred a dark background. We created our own theme which we think it is pretty cool.

Let us know what you think. Here is an screenshot of the new theme:

One way to solve this was to serialize the input and outputs of the application using a JSON Serializer (or an XML Serializer). This worked ok, but it poluted the iKnode application with unnecessary serialize/deserialize code, making the application code more difficult to maintain.

The full purpose of iKnode is to make it extremely simple to create services in the cloud, automating things like security configuration, performance configuration and also serialization of custom objects.

We are proud to announce that iKnode now supports custom objects as input and as output. The way it works is with automatic serialization of custom objects into JSON.

Let’s try an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

using System;
using iKnode.Applications;

namespace Applications
{
    /// <summary>
    /// Defines the Custom Objects Test Application.
    /// </summary>
    [Application]
    public class CustomObjectsTest
    {
        /// <summary>
        /// Creates a Default User.
        /// </summary>
        /// <remarks>
        /// This method tests the return of a custom object of Type <c>Client</c>.
        /// </remakrs>
        /// <returns>Client Information.</returns>
        public Client CreateDefault()
        {
            return new Client(1, new FullName("Alex", "Espinoza"));
        }

        /// <summary>
        /// Creates the select User.
        /// </summary>
        /// <remarks>
        /// This method tests the return of a custom object of Type <c>Client</c>.
        /// And also the input of a custom object of Type <c>FullName</c>
        /// </remakrs>
        /// <returns>Client Information.</returns>
        public Client CreateClient(int id, FullName name)
        {
            return new Client(id, name);
        }
    }

    /// <summary>
    /// Defines the Full Name class.
    /// </summary>
    [Serializable]
    public class FullName
    {
        public string FirstName;
        public string LastName;

        public FullName(string firstName, string lastName)
        {
            this.FirstName = firstName;
            this.LastName = lastName;
        }
    }

    /// <summary>
    /// Defines the Client class.
    /// </summary>
    [Serializable]
    public class Client
    {
        public int Id;
        public FullName Name;

        public Client(int id, FullName name)
        {
            this.Id = id;
            this.Name = name;
        }
    }
}

We have 3 classes in our application, one that defines the Application class CustomObjectsTest and two classes used as input and output for the application Client and FullName. As you can see, both the Client class and the FullName class have the serializable attribute. Classes used as input/output for the application need to be serializable to work.

Let’s execute the method CreateDefaultUser():

As you can see, the output is already formatted as a JSON object. If you look at the result in the JSON viewer, you’ll be able to see the full client object in a nicer way.

Now let’s try the other method, to test the FullName object as a parameter. Input the following JSON in the fullName parameter and then click execute:

1

{"FirstName":"John","LastName":"Doe"}

As you can see newly created object includes the correct full name:

Now when the iKnode Application gets call, it can be easily deserialized with the Newtonsoft JSON Library:

1

Client defaultClient = JsonConvert.DeserializeObject<Client>(jsonClient);

And Serialized like this:

1

string output = JsonConvert.SerializeObject(fullName);

For this to work, you would need to share the Client and FullName object. This example includes the Client and FullName object inside of the iKnode App for demostration purposes, but I recommend you have those in an assembly that can be shared between your Mobile or Web App and the iKnode App.

Let us know what you think.