OldMusicBox.ePUAP.Client released to NuGet

The ePUAP Client has been released to NuGet. It allows your app to perform the SSO but it also shows how to sign arbitrary XML documents using AddDocumentToSigning/GetSignedDocument functions.

The documentation as well as an example application are provided at the GitHub project page.

I hope this would be usedful for anyone who wants to learn how ePUAP integration works. The next step is Węzeł Krajowy.

OldMusicBox.ePUAP.Client milestone reached

I am happy to announce that the ePUAP client library, the OldMusicBox.ePUAP.Client has reached its first important milestone where you can actually single sign on to your app through ePUAP.

This means that all three steps work correctly:

1. The SAML2 AuthnRequest is correctly issued
2. The SAML2 ArtifactResolve is correctly issued
3. The ePUAP getTpUserInfo is correctly called

The road map for few days is:

• Add support for Single Log Out (LogoutRequest, LogoutResponse)
• Add support for document signing (tpSigning interface)
• Release the Client to NuGet

Please note that while the SAML2 component is licensed under the MIT license, the ePUAP Client is licensed under the AGPL-3. However, you are free to download the code and use it according to the license. Any issues or feature requests are welcome.

OldMusicBox.ePUAP.Client announcement

I've just created a repo for the upcoming independent .NET ePUAP Client. The goal here is to provide an open source implementation under AGPL-3.0 license. Please keep your fingers crossed and expect working code in a week or two.

OldMusicBox.Saml2 0.65 published

I hereby announce that the very first public version of the SAML2 library has been published on NuGet. This first release contains the core part of the SAML2 client interface, including REDIRECT/POST/ARTIFACT binding and LogoutRequest/LogoutResponse support.

The next step is to build the ePUAP client library on top of this SAML2 implementation. I will officially announce it in a couple of days.

An independent SAML2 client/server library

I started to work on an independent SAML2 client/server library that would target classic .NET Framework. The source code is available on GitHub, the repo's name is OldMusicBox.Saml2. I decided to release it under MIT license.

The long-time goal is to cover most SAML2 features and target .NET Core.

The short-time goal is to have basic features quickly so that it's possible to use this in other projects. In particular, based on feedback I get from people, I believe the community needs an independent Profil Zaufany client library. This one, when it's ready, will be released under more strict license (so that I could control where and how it's used). The plan is to make it available in few weeks and somewhere in future add the support of the Krajowy Węzeł Identyfikacji Elektronicznej.

How valid data leads to problematic conclusions

For people who got used to the New Project dialog, finding an appropriate project type raises no issues at all. The tree-like structure (the same for years) make the navigation quick and you always follow the same pattern "language-framework-project type".

Visual Studio 2019 introduces the new look of the dialog. There's a Visual Studio Blog entry with a story behind the new look. In short, they've collected the telemetry data (the data that is automatically collected by the VS and sent back to Microsoft), performed some interviews and observed that developers are confused by the taxonomy presented on the project tree which causes the drop-off to opening a project.

Where the telemetry data is possibly objective, the interpretation is not. The team seems to put everyone in the very same basket - someone who just downloaded the VS and runs it for the first time in their life and a professional who uses VS for almost two decades. In the latter case, the team observed that even for experienced developers, some of the options weren’t intuitive. Most couldn’t pinpoint the link to ‘Open Visual Studio Installer’ when the templates they were looking for weren’t available. What's the solution to all these (very different issues)?

This:

Every single developer I ask (myself included) is disappointed by the new look and the behavior of this something. Example comments from below the blog entry:

• From my own experience, I find it more confusing and time consuming to create new projects with the new dialog concept.
• Yes, this new dialog is the worst experience from VS 2019.
• I liked old new project dialog more. New one is confusing.
• This new dialog just ensures that most developers will only ever see the top 5 or so project templates and that the rest of them may as well not even exist.
• I absolutely positvely hate the new dialog.

The list continues in a similar manner so guess what ... the comment section has been closed.

The good news is that there's an Extension in the marketplace, the Classis "New Project" Dialog and the feedback here is expected

• Thank you. Thank you. Thank you.
• From one extension developer to another one - well done!
• Thank you! This saved my life. I found the out of box "New project" dialog of VS2019 to be very limiting.

Download and rate this extension and have at least one inconvenience resolved. Whoever wrote the extension - thank you for your contribution.

Your XSLT processor is Turing Complete

Just by change I stumpled upon a nice approach to proving that XSLT processors are Turing Complete. This approach by Unidex involves a XSLT definition that implements the Turing Machine and an example language of writing Turing machines in XML.

(Note that the page is there for quite some time so when it's down somewhere in future, use the WayBackMachine to access it)

If you want to try it, download the XSLT, download the example and put the two together with a simple snippet:

        static void Main(string[] args)
        {
            var transform = new XslCompiledTransform();
            transform.Load(XmlReader.Create(File.Open("turing.xslt", FileMode.Open)));

            StringBuilder sb = new StringBuilder();
            StringWriter sw = new StringWriter(sb);

            var p = new XsltArgumentList();
            p.AddParam("tape", "", "199");
            transform.Transform(XmlReader.Create(File.Open("turing.xml", FileMode.Open)), p, sw);

            Console.WriteLine(sb.ToString());

            Console.ReadLine();
        }

Running this yields

Step number = 1
Tape        = 199
Tape head     ^
State       = go_right
Next symbol = 1
Next state  = go_right
Movement    = right

Step number = 2
Tape        = 199
Tape head      ^
State       = go_right
Next symbol = 9
Next state  = go_right
Movement    = right

Step number = 3
Tape        = 199
Tape head       ^
State       = go_right
Next symbol = 9
Next state  = go_right
Movement    = right

Step number = 4
Tape        = 199
Tape head        ^
State       = go_right
Next symbol =
Next state  = increment
Movement    = left

Step number = 5
Tape        = 199
Tape head       ^
State       = increment
Next symbol = 0
Next state  = increment
Movement    = left

Step number = 6
Tape        = 190
Tape head      ^
State       = increment
Next symbol = 0
Next state  = increment
Movement    = left

Step number = 7
Tape        = 100
Tape head     ^
State       = increment
Next symbol = 2
Next state  = stop
Movement    = left

The Turing machine has halted.
Final state = stop
Final tape  =  200
Tape head     ^