Contents

213 Articles
12 Comments

Search

2 days Ago

C# 9: finally, covariant returns

Published by marco on

The article Welcome to C# 9.0 by Mads Torgersen (Microsoft Dev Blogs) (May 2020) introduces several nifty new features that I am really looking forward to using.

What about C# 8?

I still haven’t moved Quino to C# 8, as the only feature I’d love to have there is the non-nullable types, which ReSharper Annotations provide with earlier versions of C#. Not only that, but the nullabilities are properly propagated to users of Quino. It’s understood that recent versions of Visual Studio and runtimes and compilers also do this but, until... [More]

2 months Ago

W3C Web Animations

Published by marco on

The Web Animations Working Draft (W3C) was published in October of 2018. Can I use “Web Animations” (CanIUse) shows that the only browser that supports this API 100% is the latest technology preview on iOS and MacOS. Chromium-based browsers have had (very) basic support for quite some time, but Safari has thrown down the gauntlet with full support, which I learned about from Web Animations in Safari 13.1 by Antoine Quint (WebKit Blog).

This API is intended to replace many usages of CSS Animations and CSS Transitions, which are not only... [More]

PostgreSql Drawbacks

Published by marco on

Despite the title, from what I can gather from 10 Things I Hate About PostgreSQL by Rick Branson (Medium), the author is a big fan of PostgreSql. However, he has such vast experience with it that he can still list 10 things that don’t work as well as they could.

They seem to boil down to:

  • Default replication is still serialized and therefore not as reliable as the alternative async protocol that is much harder to configure and pretty much what every other major database offers.
  • Obsolete-data-handling requires... [More]

Getting started with D3.js

Published by marco on

 The programmable notebook Introduction to D3 by Arvind Satyanarayan (MIT Visualization Group) is part of a full course at MIT about Interactive Data Visualization.

The linked notebook uses D3.js, but previous classes in the course have dealt with Vega, which is,

“[…] a visualization grammar, a declarative language for creating, saving, and sharing interactive visualization designs. With Vega, you can describe the visual appearance and interactive behavior of a visualization in a JSON format, and generate web-based views using Canvas or SVG.... [More]”

Rust: from zero to pretty-well-versed in 30 minutes

Published by marco on

I found the article A half-hour to learn Rust by Amos to be extremely helpful in learning the syntax and mechanics of Rust.

It starts out with the absolute basics:

let introduces a variable binding […]”

then takes you through

  • Modules
  • Blocks
  • Conditionals
  • Matches
  • Options
  • mutables
  • Copy/clone semantics
  • Traits
  • Generic parameters
  • Constraints
  • Macros
  • Enums
  • Lifetimes and borrowing
  • Generic lifetimes
  • Statics vs. owned vs. referenced
  • Slices and range literals (Index and IndexMut)
  • Results
  • Errors, panic and unwrap... [More]

3 months Ago

Quino 2020 Roadmap

Published by marco on

Now that Quino 8.x is out the door, we can look forward to Quino 9.

Quino 8 is a very solid and stable release that has already been test-integrated into many of our current products running on Quino. We don’t anticipate any more low-level API changes, though there will be follow-up bug-fix releases.

There are a few larger-scale changes improvements and enhancement, outlined below (and noted in the roadmap).

Ready for Change

With this release, we’ve got more coverage than ever. Excluding... [More]

Quino v8.0.0: ASP.NET Core, Web Client 2, Culture/Language improvements

Published by marco on

The summary below describes major new features, items of note and breaking changes.

The links above require a login.

Highlights

When [NotNull] is null

Published by marco on

I prefer to be very explicit about nullability of references, wherever possible. Happily, most modern languages support this feature non-nullable references natively (e.g. TypeScript, Swift, Rust, Kotlin).

As of version 8, C# also supports non-nullable references, but we haven’t migrated to using that enforcement yet. Instead, we’ve used the JetBrains nullability annotations for years.[1]

Recently, I ended up with code that returned a null even though R# was convinced that the value could never... [More]

4 months Ago

Configuring .NET Framework Assembly-binding Redirects

Published by marco on

After years of getting incrementally better at fixing binding redirects, I’ve finally taken the time to document my methodology for figuring out what to put into app.config or web.config files.

The method described below works: when you get an exception because the runtime gets an unexpected version of an assembly—e.g. “The located assembly’s manifest definition does not match the assembly reference”—this technique lets you formulate a binding-redirect that will fix it. You’ll then move on... [More]

5 months Ago

Rebase Considered Essential

Published by marco on

Fossil is a distributed Source Control Manager that claims to offer the same power without the complexity of Git. The article Fossil: Rebase Considered Harmful by D. Richard Hipp (Fossil SCM) is part of the documentation for the tool.

One of the main selling points of Fossil is that it does not support rebase. In the article, the author lays out the many ways in which rebasing causes no end of woes for developers using Git.

I’d heard of Fossil before and I’d even skimmed this document before. This time around, though, I... [More]

Advanced CSS (blend modes and subgrids)

Published by marco on

The article Z’s Still Not Dead Baby, Z’s Still Not Dead by Andy Clarke (24 Ways) is well-written, very interesting and taught me a few new CSS tricks of which I was unaware.

Granted, my work usually doesn’t call for fancy effects like those you can achieve with something like background-blend-mode, but it can happen. There’s not only background-blend-mode, there’s also mix-blend-mode and filter, all of which apply high-quality effects dynamically.

In the late spring, I had a two-month project where I had to use a lot... [More]

6 months Ago

Framework Design: Programming Paradigms and Idioms

Published by marco on

The discussion React in concurrent mode: 2000 state-connected comps re-rendered at 60FPS (YCombinator) is illuminating mostly in that it shows how ego can impede productivity.

Ego-driven design

Ego can also be that thing that drives a talented programmer to create something of use to the rest of us, but that’s honestly a very rare case. More often than not, the best case is that a developer improves their skills—and perhaps learns to be more humble instead of shooting of their mouth about how “easy” it... [More]

Thoughts on Atomic/Utility CSS

Published by root on

The article In Defense of Utility-First CSS by Sarah Dayan on January 15th, 2018 (Frontstuff) is very long[1], so I’ve summarized a bit with notes and thoughts.[2]

I don’t really care about being pedantic without first knowing some facts. What are the requirements?

Requirements

  • Can I quickly make a precise change to a single component?
  • Can I make a global, thematic change?
  • How quickly can I make changes?
  • How maintainable is the result?

If atomic/utility CSS can deliver these things, then it’s probably a fine tool. But—spoiler alert—it... [More]

8 months Ago

Azure Linked Accounts and SSH Keys

Published by marco on

Azure DevOps allows you to link multiple accounts.

Our concrete use case was:

  • User U1 was registered with an Azure DevOps organization O1
  • Microsoft did some internal management and gave our partner account a new organization O2, complete with new accounts for all users. Now I have user U2 as well, registered with O2.
  • U2 was unable to take tests to qualify for partner benefits, so I had to use U1 but link the accounts so that those test results accrued to O2 as well as O1.
  • We want to start... [More]

Using Git efficiently: SmartGit + BeyondCompare

Published by marco on

I’ve written about using SmartGit (SG) before[1][2] and I still strongly recommend that developers who manage projects use a UI for Git.

If you’re just developing a single issue at a time and can branch, commit changes and make pull requests with your IDE tools, then more power to you. For this kind of limited workflow, you can get away with a limited tool-set without too big of a safety or efficiency penalty.

However, if you need an overview or need to more management, then you’re going to... [More]

Visual Studio 2019 Survey

Published by marco on

Visual Studio 2019 (VS) asked me this morning if I was interested in taking a survey to convey my level of satisfaction with the IDE.

VS displays the survey in an embedded window using IE11.[1] I captured the screen of the first thing I saw when I agreed to take the survey.

 Visual Studio 2019 Survey error

I know it’s the SurveyMonkey script that’s failing, but it’s still not an auspicious start.


[1] I’d just upgraded to Windows 10 build 1903, which includes IE 11.418.18362.0. I can’t imagine that they didn’t test this... [More]

1 year Ago

Svelte vs. React (overselling a framework as a revolution)

Published by marco on

I’ve just read about a web framework called Svelte in the post Virtual DOM is pure overhead. I think the product itself sounds interesting, but that the author uses unnecessarily misleading arguments.

From what I gather, Svelte is a compile-time reconciliation generator for JSX/TSX components. This pre-calculated generator applies changes to the DOM without needing a virtual DOM and without real-time diffing or reconciliation. That is, instead of having real-time calculation, with possible... [More]

Why use an IOC? (hint: testing)

Published by marco on

Inversion of Control Pattern

The IOC pattern is the [I] in SOLID. It stands for “Inversion of Control”.

In order to make good use of this pattern, an application should adhere to the following rules:

  • Prefers composition over inheritance, exposing clear dependencies
  • Refers to dependencies via interface or protocol types with as small a surface area as possible Obtains dependencies through injection, preferably in the constructor

Components built in this manner are agnostic in their... [More]

Using Unity, Collab and Git

Published by marco on

If you’re familiar with the topic, you might be recoiling in horror. It would be unclear, though, whether you’re recoiling from the “using Collab” part or the “using Collab with Git” part.

Neither is as straightforward as I’d hoped.

tl;dr: If you have to use Collab with Unity, but want to back it up with Git, disable core.autocrlf[1] and add * -text to the .gitattributes.

Collab’s Drawbacks

Collab is the source-control system integrated into the Unity IDE.

It was built for designers to be... [More]

Finding deep assembly dependencies

Published by marco on

Quino contains a Sandbox in the main solution that lets us test a lot of the Quino subsystems in real-world conditions. The Sandbox has several application targets:

  • WPF
  • Winform
  • Remote Data Server
  • WebAPI Server
  • Console

The targets that connect directly to a database (e.g. WPF, Winform) were using the PostgreSql driver by default. I wanted to configure all Sandbox applications to be easily configurable to run with SqlServer.

Just add the driver, right?

This is pretty straightforward for a... [More]

QQL: A Query Language for Quino

Published by marco on

In late 2011 and early 2012, Encodo designed a querying language for Quino. Quino has an ORM that, combined with .NET Linq provides a powerful querying interface for developers. QQL is a DSL that brings this power to non-developers.

QQL never made it to implementation—only specification. In the meantime, the world moved on and we have common, generic querying APIs like OData. The time for QQL is past, but the specification is still an interesting artifact, in its own right.

Who knows? Maybe... [More]

Breaking Changes in C#

Published by marco on

Due to the nature of the language, there are some API changes that almost inevitably lead to breaking changes in C#.

Change constructor parameters

While you can easily make another constructor, marking the old one(s) as obsolete, if you use an IOC that allows only a single public constructor, you’re forced to either

  • remove the obsolete constructor or
  • mark the obsolete constructor as protected.

In either case, the user has a compile error.

Virtual methods/Interfaces

There are several... [More]

Version numbers in .NET Projects

Published by marco on

Any software product should have a version number. This article will answer the following questions about how Encodo works with them.

  • How do we choose a version number?
  • What parts does a version number have?
  • What do these parts mean?
  • How do different stakeholders interpret the number?
  • What conventions exist for choosing numbers?
  • Who chooses and sets these parts?

Stakeholders

In decreasing order of expected expertise,

  • Developers: Writes the software; may *change* version numbers
  • Testers:... [More]

v6.0: .NET Standard & Authentication

Published by marco on

Note: this article was originally published at Encodo.com at the end of October, 2018.


The summary below describes major new features, items of note and breaking changes.

The links above require a login.

Overview

At long last, Quino enters the world of .NET Standard and .NET Core. Libraries target .NET Standard 2.0, which means they can all be used with any .NET runtime... [More]

Learning Quino: a roadmap for documentation and tutorials

Published by marco on

Note: this article was originally published at Encodo.com in July, 2018.


In recent articles, we outlined a roadmap to .NET Standard and .NET Core and a roadmap for deployment and debugging. These two roadmaps taken together illustrate our plans to extend as much of Quino as possible to other platforms (.NET Standard/Core) and to make development with Quino as convenient as possible (getting/upgrading/debugging).

To round it off, we’ve made good progress on another vital piece of any... [More]

Delivering Quino: a roadmap for deployment

Published by marco on

Note: this article was originally published at Encodo.com in July, 2018.


In a recent article, we outlined a roadmap to .NET Standard and .NET Core. We’ve made really good progress on that front: we have a branch of Quino-Standard that targets .NET Standard for class libraries and .NET Core for utilities and tests. So far, we’ve smoke-tested these packages with Quino-WebApi. Our next steps there are to convert Quino-WebApi to .NET Standard and .NET Core as well. We’ll let you know when it’s... [More]

Removing unwanted references to .NET 4.6.1 from web applications

Published by marco on

Note: this article was originally published at Encodo.com in July, 2018.


The title is a bit specific for this blog post, but that’s the gist of it: we ended up with a bunch of references to an in-between version of .NET (4.6.1) that was falsely advertising itself as a more optimal candidate for satisfying 4.6.2 dependencies. This is a known issue; there are several links to MS GitHub issues below.

In this blog, I will discuss direct vs. transient dependencies as well as internal vs. runtime... [More]

Quino’s Roadmap to .NET Standard and .NET Core

Published by marco on

Note: this article was originally published at Encodo.com in May, 2018.


With Quino 5, we’ve gotten to a pretty good place organizationally. Dependencies are well-separated into projects—and there are almost 150 of them.

We can use code-coverage, solution-wide-analysis and so on without a problem. TeamCity runs the ~10,000 tests quickly enough to provide feedback in a reasonable time. The tests run even more quickly on our desktops. It’s a pretty comfortable and efficient experience,... [More]

Convert Markdown to earthli format

Published by marco on

The earthli blogging format uses HTML-like formatting, described in the lengthy manual (with examples). However, Encodo’s blogging back-end now uses Umbraco, with Markdown for content. I used to be able to cross-post with ease, by copy/pasting. Now, I need to convert the content from Markdown to earthli formatting.

The following steps suffice to convert any article:

  1. If there are attached media (e.g. graphics), save those locally
  2. Create a new earthli article with the same title as the source... [More]

Compiler Pessimism

Published by marco on

“In practice, nearly everything you write is potentially dependent upon the order of evaluation, but in practice it isn’t because you are not a nincompoop.”

He completes the thought with “[b]ut the compiler doesn’t know that. The compiler must adhere to the letter of the language standard, because it has to compile insane code as well as sane code.”