2014-12-15-capnproto-0.5-generics-msvc-java-csharp.md (6732B)
1 --- 2 layout: post 3 title: "Cap'n Proto 0.5: Generics, Visual C++, Java, C#, Sandstorm.io" 4 author: kentonv 5 --- 6 7 Today we're releasing Cap'n Proto 0.5. We've added lots of goodies! 8 9 ### Finally: Visual Studio 10 11 Microsoft Visual Studio 2015 (currently in "preview") finally supports enough C++11 to get Cap'n 12 Proto working, and we've duly added official support for it! 13 14 Not all features are supported yet. The core serialization functionality sufficient for 90% of users 15 is available, but reflection and RPC APIs are not. We will turn on these APIs as soon as Visual C++ 16 is ready (the main blocker is incomplete `constexpr` support). 17 18 As part of this, we now support CMake as a build system, and it can be used on Unix as well. 19 20 In related news, for Windows users not interested in C++ but who need the Cap'n Proto tools for 21 other languages, we now provide precompiled Windows binaries. See 22 [the installation page]({{site.baseurl}}install.html). 23 24 I'd like to thank [Bryan Boreham](https://github.com/bboreham), 25 [Joshua Warner](https://github.com/joshuawarner32), and [Phillip Quinn](https://github.com/pqu) for 26 their help in getting this working. 27 28 ### C#, Java 29 30 While not strictly part of this release, our two biggest missing languages recently gained support 31 for Cap'n Proto: 32 33 * [Marc Gravell](https://github.com/mgravell) -- the man responsible for the most popular C# 34 implementation of Protobufs -- has now implemented 35 [Cap'n Proto in C#](https://github.com/mgravell/capnproto-net). 36 * [David Renshaw](https://github.com/dwrensha), author of our existing Rust implementation and 37 [Sandstorm.io](https://sandstorm.io) core developer, has implemented 38 [Cap'n Proto in Java](https://github.com/dwrensha/capnproto-java). 39 40 ### Generics 41 42 Cap'n Proto now supports [generics]({{site.baseurl}}language.html#generic-types), 43 in the sense of Java generics or C++ templates. While working on 44 [Sandstorm.io](https://sandstorm.io) we frequently found that we wanted this, and it turned out 45 to be easy to support. 46 47 This is a feature which Protocol Buffers does not support and likely never will. Cap'n Proto has a 48 much easier time supporting exotic language features because the generated code is so simple. In 49 C++, nearly all Cap'n Proto generated code is inline accessor methods, which can easily become 50 templates. Protocol Buffers, in contrast, has generated parse and serialize functions and a host 51 of other auxiliary stuff, which is too complex to inline and thus would need to be adapted to 52 generics without using C++ templates. This would get ugly fast. 53 54 Generics are not yet supported by all Cap'n Proto language implementations, but where they are not 55 supported, things degrade gracefully: all type parameters simply become `AnyPointer`. You can still 56 use generics in your schemas as documentation. Meanwhile, at least our C++, Java, and Python 57 implementations have already been updated to support generics, and other implementations that 58 wrap the C++ reflection API are likely to work too. 59 60 ### Canonicalization 61 62 0.5 introduces a (backwards-compatible) change in 63 [the way struct lists should be encoded]({{site.baseurl}}encoding.html#lists), in 64 order to support [canonicalization]({{site.baseurl}}encoding.html#canonicalization). 65 We believe this will make Cap'n Proto more appropriate for use in cryptographic protocols. If 66 you've implemented Cap'n Proto in another language, please update your code! 67 68 ### Sandstorm and Capability Systems 69 70 [Sandstorm.io](https://sandstorm.io) is Cap'n Proto's parent project: a platform for personal 71 servers that is radically easier and more secure. 72 73 Cap'n Proto RPC is the underlying communications layer powering Sandstorm. Sandstorm is a 74 [capability system](http://www.erights.org/elib/capability/overview.html): applications can send 75 each other object references and address messages to those objects. Messages can themselves contain 76 new object references, and the recipient implicitly gains permission to use any object reference 77 they receive. Essentially, Sandstorm allows the interfaces between two apps, or between and app 78 and the platform, to be designed using the same vocabulary as interfaces between objects or 79 libraries in an object-oriented programming language (but 80 [without the mistakes of CORBA or DCOM]({{site.baseurl}}rpc.html#distributed-objects)). 81 Cap'n Proto RPC is at the core of this. 82 83 This has powerful implications: Consider the case of service discovery. On Sandstorm, all 84 applications start out isolated from each other in secure containers. However, applications can 85 (or, will be able to) publish Cap'n Proto object references to the system representing APIs they 86 support. Then, another app can make a request to the system, saying "I need an object that 87 implements interface Foo". At this point, the system can display a picker UI to the user, 88 presenting all objects the user owns that satisfy the requirement. However, the requesting app only 89 ever receives a reference to the object the user chooses; all others remain hidden. Thus, security 90 becomes "automatic". The user does not have to edit an ACL on the providing app, nor copy around 91 credentials, nor even answer any security question at all; it all derives automatically and 92 naturally from the user's choices. We call this interface "The Powerbox". 93 94 Moreover, because Sandstorm is fully aware of the object references held by every app, it will 95 be able to display a visualization of these connections, allowing a user to quickly see which of 96 their apps have access to each other and even revoke connections that are no longer desired with 97 a mouse click. 98 99 Cap'n Proto 0.5 introduces primitives to support "persistent" capabilities -- that is, the ability 100 to "save" an object reference to disk and then restore it later, on a different connection. 101 Obviously, the features described above totally depend on this feature. 102 103 The next release of Cap'n Proto is likely to include another feature essential for Sandstorm: the 104 ability to pass capabilities from machine to machine and have Cap'n Proto automatically form direct 105 connections when you do. This allows servers running on different machines to interact with each 106 other in a completely object-oriented way. Instead of passing around URLs (which necessitate a 107 global namespace, lifetime management, firewall traversal, and all sorts of other obstacles), you 108 can pass around capabilities and not worry about it. This will be central to Sandstorm's strategies 109 for federation and cluster management. 110 111 ### Other notes 112 113 * The C++ RPC code now uses `epoll` on Linux. 114 * We now test Cap'n Proto on Android and MinGW, in addition to Linux, Mac OSX, Cygwin, and Visual 115 Studio. (iOS and FreeBSD are also reported to work, though are not yet part of our testing 116 process.)