Monday, January 02, 2023

Anime 2022

aka the year Funiroll paywalled most things.

Still I did get to watch some things

Clearing up from the backlog -- Un-Go which was weird detective story in a near/alt-future Japan after a war, with a mix of AI, powersat-politics and battling kami : OK but who comes up with mix-and-match ideas like that to even make them work in the first place?

Heroic Age did what one pretty much might have expected from the initial (and well-trodden in the literature) premise, and thus did manage to stick a satisfactory ending.

Nobunagun turned out to be a fun take on the "super-powered school-girl vs alien greeblies" genre, when ditzy mil-otaku Sio goes all-in when she discovers she can channel Oda Nobunaga in the form of a Gatling gun with moar dakka-dakka. This had the weirdest take yet out of Japan for the secret identity of Jack the Ripper.

Schoolgirl Strikers was a more genre-pure instance of super-powered school-girls vs alien greeblies, with some added power of friendship -- it managed to do things right which Ange Vierge spectacularly fumbled, including having most off the non-combat sections being elsewhere than the hot tub.

In the "Cute Girls Do Cute Activity" corner, New Game! presented a very sanitized -- and very gender-bent -- view of the software development process; New Game!! was more of exactly the same, but I hope that code review, and check-in integration and testing, are handled better than in the anime, in the same way one hopes the code from Senko-san is not representative of real life.

When watched in binge mode, rather than weekly-as-aired, Space Brothers flows much better than it did at the time -- the introductory recaps can be ignored, along with the 3-episode mid-run total to-date recap. Watching 10 years on, there is also the amusement at the near future that has NASA getting to the moon again, with not a hint of SpaceX-style private space activity - at least not this side of the "now read the manga" last episode.

And for something completely different, Akiba's Trip, to see the context for the otaku memes it spawned (e.g. "It doesn't matter what a man's salary is worth; what matters is how much of it he spends on his hobbies!"). It lampoons one otaku hobby a week, including actual Street Fighter V gameplay footage in the vidya episode, before wrapping up with the big boss fight. Also, clothes get removed in every battle. Verdict : entirely harmless.

Interrupted by paywalling at the half-way point, C3 was just slightly weird; 18if, with its witch-of-the-week formula didn't leave things quite as hanging, and in places seemed to be unexpectedly good in its variety (cf Sengoku Collection). It also gets an honourable mention for the episode where the WotW is intending to kill three nasty pieces of work who killed her family - and while MC's mentor is all "then you'll be as bad as they are", the MC says in effect "sounds reasonable to me; do you need any help?", taking over for the boss bad's turn.

From the Winter season the one-shot Sorairo Utility was too short to establish real "a cute girls doing activity" scenario; Sabikui Bisco was crazy enough in its take on the "a random disaster strikes (at least) Japan, and things become weird and anarchic" genre to follow to the end, though the finale echoed Vividred Operation for the way all the characters spent time being heartfelt at each other while the big bad was charging up his lazors -- in all, too many crazy ideas, and not really enough establishing of conflict; and my reaction to Tokyo 24th Ward was simply this

Akebi's Sailor Suit didn't establish itself as an alternative CGD-whatever, and the weird art style didn't help motivate; I ended up finishing it as a backlog item. For most of the season after the first episode, it was not too far from being "creepy lesbian stalker sue adds girl of the week to her harem" (exceptions like the episode where the girl of the week is a stalker herself and they prowl together hardly count). After all these years, I confess that I don't understand the neuroticism about having/making friends in high-school that percolates some series (Uruhara being another example of same that springs to mind). Perhaps it's a girl thing. After a while one habituates to the slightly uncanny character designs, as it works towards the big sports' day climax - a change from the usual school festival trope. Verdict: harmless.

The charge of "too much crazy, too little establishment" for Sabikui Bisco can also be levelled at Spring's (gacha-game tie-in) series Estab-Life, which adds the one-style-fits-all 3DCG characters that are becoming too common these days, including an apparent high-school girl with a long track record as an operative (on a par with the Dirty Pair, but without the associated trail of destruction). In all, mostly harmless, somewhat silly.

At mid-year, everything got paywalled, so I only watched the teaser episodes of LycoReco, and was spared what sounded like a disappointing thud of an ending

With winter came Pui Pui Molcar : Driving School. After the first season's "everything goes" mayhem, it was hard to see where they could take it, but this new set-up makes sense. Which may be why it's just so-so. Still, a harmless few minutes of Saturday morning cartoon.

Q4 cycling

Overall mild, but wet in November, and cold in mid-December, so a steady background of utility rides, kept the numbers up.

Tree down

Despite the previous month's rain, such had been the drought that October remained off-road season, with firm going on bridleways. With mild weather and light in the afternoons, plenty of business rides, and a few longer ones to do things like checking the progress of the cycle-path signed to Longstanton, or the newly placed archaeological signs along the A1307.

End of the line at Northstowe

Totals at the end of the month 1862.2 on the old bike (+321.2), 2133 on the new (+87.3), for a total of 408.2 miles for the month, 4185 YTD.

Second load

November's weather was less clement, but, with old customs resuming, I did get the chance to use the trailer I'd bought for my birthday, to transport bits of old fencing that had been languishing for more than a year to the village bonfire for disposal. And while there were a few dodgy spots, off-road remained feasible until almost the very end of the month, provided a decent interval was left after each fall of rain.

Mostly dry, still

Totals at the end of the month 2048.9 on the old bike (+186.7), for a total of 186.7 miles for the month, 4372 YTD.

It was like that when I found it

Apart from a long ride to visit friends between Christmas and the New Year (partly into the teeth of a small gale on the way back), December's rides were at most into town. The main highlights were infrastructure related, like the unofficial opening of a stretch of the segregated route into town that had been fenced off for nearly a month; and, of course, an anniversary visit to the Abbey bridge to see that the desire line was not being thwarted by red tape - just that, as last year, the going was a bit soft just at the moment.

Desire line one year on

Totals at the end of the month 2279 on the old bike (+230.1), 175.96 on the folder (+16.2) for a total of 246.3 miles for the month, 4618 for the year; almost 10% more than my previous best of 4215 miles in 2014 when cycle commuting 19 miles was a regular thing. To think that I worried about retirement taking that base-load away, and leaving me lacking exercise!

Sunday, January 01, 2023

AltCover - 5 years on : what happened in 2022

2022 was a comparatively quite year, only 8 releases in all, mostly bugfixing, tracking compiler changes, or working around places where I put Mono.Cecil under unexpected stress, and have to work around until it gets a next release; but with a lot of changes in processes, under the covers. You can read the release notes for the details; this post is aimed at the bits that the end user shouldn't see.

The year started by getting my FxCop wrapper into a state where I could persuade it to process netstandard2.0 assemblies, at least most of the time, thereby enabling me to drop the debug-only net472 builds for libraries. Not all net472 builds could in fact be processed - the Avalonia-based GUI threw intractably even though it could build happily against that target -- The following error was encountered while reading module 'System': Security attribute type does not have a default constructor.

Allowing assembly-level suppression attributes meant that I could also enhance the Gendarme-based scrutiny of the codebase; even if sticking at netstandard2.0 means warnings about not using preferred method overrides from later API levels.

The release of Cake v2 gave me excuse to test and update the relevant APIs -- and another such overhaul in the autumn with Cake 3.0 dropping the deprecated NetCore names.

This was the year to also add dependabot, mostly for keeping the CI build actions up to date, with some prompting about other dependencies; though things like F# updates with compiler changes were actually the most significant unexpected maintenance-level change.

As a maintenance tool, fantomas matured this year, especially with its integration of .editorconfig, to the point that there are only a few "quirky" files where I have to back changes out, mostly with hacky #if/#endif nesting; so it's an on-going tool rather than a once-per release spring-clean. The worst bit is when a compiler generated method with a line-number in its name gets moved, and the static analysis suppression shutting up warning about the bad habits of code generators has to be updated.

The already massive Fake build script also increased its level of automation, keeping track of SDK versions via XML parsing of project files, to keep static analysis dependency paths up to date.

Belatedly, after the release in late 2021, the icons for VS2022 became available, and have been incorporated into the visualizer; this was also the year when I dropped the abortive FuncUI stub, and instead started to experiment with the massive changes in Avalonia 11 - that will be something on-going into the coming year!

Having started to centralize build process late in '21 by using Directory.Build.* files, late '22 saw the adoption of central package versioning, which simplifies much of the update process across the multi-solution sprawl. On the upside, while there's only one place to update, the Visual Studio UI doesn't do that, so while it can identify the updates, it's still a manual process at that one point. It also means having to add more verbiage to Nuget.config files intended to consume just-minted packages as part of build validation testing.

The big change at the end was not net7.0 itself (problems with the 7.0.100 release on dotnet test aside), but the way that didn't play well with the Fake CLI tool, or with the Appveyor CI; so I've replaced the former with net7.0 built drivers for what were scripts and are now source files within the drivers; and the latter with GitHub for doing things like Coveralls reporting -- redone as the old tool I'd been using stopped working at some point mid-year -- and release to NuGet. Of course with my build versioning having incorporated the AppVeyor build number, I needed to take a gratutious minor version bump as even my GitHub build numbers were lower than the AppVeyor ones. In the end, I took a big break and have (ab-)used NerdBank.GitVersioning, starting with the 1-Jan-23 anniversary release.

In many ways the 7.0.100 fail was a forunate one, as it gave me a reason to improve the AltCover scripting APIs, used extensively by AltCover's own build process, to emit raw property/value pairs rather than just composed command-line arguments; and having dropped support for early Fake5 releases, to use its property/value APIs rather than the composed command-line ones.

One last little bit of build-process work was in sorting out the assertion behaviour of Unquote - it casts about to see what libraries are visible and makes an opinionated choice (with NUnit being at the end of its preferences); a little hacking to catch and re-assert means that I can now do Assert.Multiple of Unquote tests - or take multiple bites at a failure, when Unquote tells me that two long strings differ, NUnit can point at where.

Wednesday, November 16, 2022

Hacking Fake.Build for net7.0

It's too early yet to do the AltCover after-action for net7.0 like I did for net5.0; but it is proving a slog like net5.0 rather than being too transparent to mention like net6.0 was.

While the dotnet 7.0.100 build has its own problems, the Fake build system currently (5.23.x, 6.0 alpha) doesn't handle it at all - the former may work for limited scenarios, but more complicated ones fall over with library version mismatches; the latter politely askes for a v6 runtime and stops.

So, you have a build process based on a Fake script, but want to run with v7.0.100 as SDK, through your project global.json. What do?

Well, the Fake documentation gives some alternatives - turn the script into a net7.0 project that links against the Fake libraries; but that imposes some restrictions on how you set up targets, because you can only define such things (as opposed to the functions that define the target's intended action) after setting up a build context. Or you can run as a fsi script, but the documentation then leads into how to hack paket into the mix.

However, since net5.0, scripts are able to reference nuget packages directly, so rather than having a paket.dependencies, with a #r "paket: groupref [whatever] //", and a call out to paket on the command line, your scripts can be self-contained, with a block of #r "nuget: [library][, optional version]" lines at the top, and a command line that is just dotnet fsi [my fake script.fsx]

And doing it this way, you can build on the net7.0 runtime.

Friday, October 07, 2022

F# and OpenSilver v1.1

An update to the previous series of posts following the v1.1 stable release of OpenSilver.

The recipe given as before just works, when all packages are updated and the browser project build is done with net6.0. One warning is emitted using the latest (6.0.401) SDK, about the IntermediateOutputPath override. The fix is to create a Directory.Build.props in the browser project directory, and move the two lines added to the project previously to the new file

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <IntermediateOutputPath>shorter file path here</IntermediateOutputPath>
    <BaseIntermediateOutputPath>$(IntermediateOutputPath)</BaseIntermediateOutputPath>
  </PropertyGroup>
</Project>

While the System.Windows.Application.LoadComponent API now exists, it requires build-time XAML compilation, and that the named class which it decorates exists in the same assembly, so at this time would only make an adjustment to the C# assembly, replacing the constructor InitializeComponent call with one to LoadComponent, but leaving the same inheritance in the F# layer.

It is possible that the 2.0 release will allow XAML compilation in the F# layer, but on-the-fly compilation seems not to be on the cards.

Also, in language independent mode, the ImageBrush and ImageSource APIs used by the original Silverlight AstroClock are now present. Alas, while that means uncommenting that XAML clause can be done without compile or runtime error, the interesting bits are marked NotImplemented, and live in a "work in progress" source folder, so there is currently no point in doing so.

The resulting code for running with v1.1 can be found here.

Sunday, October 02, 2022

Q3 Cycling

Hot and parched for the first two months, then cooler and damper. This meant a fair bit of riding when it was comfortable to do so, and a collapse in September.

Fen Road, Fenstanton

July was mostly business rides or enjoying the sunshine locally, with one long ride up to St. Ives at the start of the really hot spell mid-month. Notably, the month ended with the arrival of the "Our Place in Space" exhibition, which straggled from Midsummer Common, all the way to Waterbeach, with a return ride that time down Mere Way.

Inner System

Totals at the end of the month 1213.7 on the old bike (+48.8), 1438.7 on the new (+515.3), for a total of 564.1 miles for the month, 2803 YTD.

Ely in the distance

Early in the month, I did a ride through Aldreth, north through Witcham to Coveney, before returning, adding the northernmost point of the limits map. This was in the driest part of the summer, and there were signs of wildfires on Grunty Fen that looked like stubble burning had made a comeback. The dry weather also gave chance to see what Cow Lane was like in the dry (and how not-green Horse River Green had become).

I did the space ride a couple more times, to get pictures when there were fewer other folk around, exploring also the adequate (for during the day) cyclepath along the A10 from Waterbeach to Milton, and then towards the end of the month, riding up to St Ives again, up to Houghton and Wyton, before riding the St Ives perimeter road, gaining another bit of limits; then passing a major crash on the A14 and getting my photos onto the BBC news website..

Houghton Mill

Totals at the end of the month 1264.9 on the old bike (+51.2), 1913.1 on the new (+474.4), and 159.76 for the folder (+38.8) for a total of 564.4 miles for the month, 3368 YTD.

Rivey Hill West - the dry way up

Before the weather completely broke, I made another Linton to Gt Chesterford run, finding a third bridleway, and the dry way up Rivey Hill; but after a ride to explore some new trails and find lunch on my birthday, the weather broke -- some rain, but mostly cooler, so most of the rides for the rest of the month were pure A-to-B, including going to hear the city's proclamation of the new King.

Proclamation

The only long ride was the Camcycle/CTC byways and highways ride around Cambridge at the end of the month, and that mostly by virtue of having to get to and from the start in addition to the circuit (which was around the length of a pretty-way each way circuit-commute to the Science Park, if not quite the same track).

Totals at the end of the month 1541 on the old bike (+276.1), 2045.7 on the new (+132.6) for a total of 408.7 miles for the month, 3777 YTD, having passed last year's whole-year total during the group ride.


Friday, July 01, 2022

Q2 Cycling

Dry, mild to warm weather, was the overall tone of the quarter, meaning that the ground was dry enough for off-road riding; and a lot of riding did get done.

St Helen's, Colne

Good Friday, an unscripted ramble up and around the busway took me north of St. Ives, and allowed me to add a little nubbin to the east of Earith to the "Outer Limits" map (mid-green), and from there things snowballed. The Easter weekend also saw a ride along the bridleway from Little Cow Lane through Linton, following parts of the Ickneild Way -- a much drier route than the previous, until Linton, and there finding that the bridleway had a river running down the middle. And from there, the next few rides kept up the theme, following the Ickneild Way west from Gt. Chesterford, and a bit further north from Linton. The month closed with a different big ride, up byways from Rampton to Aldreth.

Totals at the end of the month 947.8 on the old bike (+336.7), 250.2 on the new (+203.1), for a total of 539.8 miles for the month, 1141 YTD.

Avenue nr Little Bradley

May Day holiday, I took more of the Ickneild Way, north from Six Mile Bottom towards Newmarket (north from Burrough Green on the Outer Limits) and back to explore the byways that linked up to the Wilbrahams; and then having pushed the limits a bit, the next week I did the section south from Burrough Green to the Thurlows, with some exploration of byways near Carlton on the return. The following week, more Ickneild Way, from Melbourne to Letchworth, and another new section of limits. Finally, rounding the month off, I took my first cycling holiday since late '17, the CycleBreaks Gardens and Gallopers tour; marred slightly by pouring rain on the first day, it was a nice mix of new, familiar and "I've only cycled this in the opposite direction before".

Totals at the end of the month 1164.9 on the old bike (+217.1), 480.9 on the new (+230.7) + 14.1 off meter, and 151 on the tour bike, for a total of 612.9 miles for the month, 1754 YTD.

Bridleway

June opened with a ride out to Burwell, the byway-defined salient on the limits map, followed by another limits buster, going down from Wendens Ambo and Newport, south of Saffron Walden to Radwinter, then taking the Little Cow Lane path back, reaching the 2000 mile mark on 15-Jun vs 21-Aug-21, then finally a reprise of the Aldreth run, this time taking the byway looping north of Haddenham to Wilburton.

Totals at the end of the month 1164.9 on the old bike (+0), 923.4 on the new (+442.5) and 120.96 (+42.5) for the folder, for a total of 485.0 miles for the month, 2239 YTD - a number which I have considered a reasonable whole-year total in the past!

Stuck in a rut


Friday, May 13, 2022

F# under the covers XIX -- `with` clauses

Once again, the half-year update has included some interesting changes in code generation, this time around try/with clauses.

Two cases to show this, one simple, one more complex. As always, decompilations are for debug (unoptimized) builds, though in this case, the release builds differ only in details of the branch instructions.

      try
        ...
      with
      | :? FormatException -> Default
      try
        ...
      with
      | :? ArgumentException as a -> a |> (logException store)
      | :? NotSupportedException as n -> n |> (logException store)
      | :? IOException as i -> i |> (logException store)
      | :? System.Security.SecurityException as s -> s |> (logException store)
      | :? UnauthorizedAccessException as u -> u |> (logException store)

Before the 6.0.300 SDK update, the simple case was entirely direct in its handling of the exception

	.try
	{
	...
		IL_006d: leave.s IL_0098
	} // end .try
	catch [netstandard]System.Object
	{
		IL_006f: castclass [netstandard]System.Exception
		IL_0074: stloc.s 8
		IL_0076: ldloc.s 8
		IL_0078: isinst [netstandard]System.FormatException

but afterwards it becomes much fancier, with duplication of effort in the handled case, and only makes sense if the exit from the filter in the unhandled case is faster than from a catch.

	.try
	{
        ...
		IL_006e: leave.s IL_00b5
	} // end .try
	filter
	{
		IL_0070: castclass [netstandard]System.Exception
		IL_0075: stloc.s 8
		IL_0077: ldloc.s 8
		IL_0079: isinst [netstandard]System.FormatException
		IL_007e: stloc.s 9
                ...
	} // end filter
	catch
	{
		IL_008c: castclass [netstandard]System.Exception
		IL_0091: stloc.s 10
		IL_0093: ldloc.s 10
		IL_0095: isinst [netstandard]System.FormatException
		IL_009a: stloc.s 11
                ...
	} // end handler

the new code being equivalent to C# catch (object obj2) when ((((Exception)obj2) is FormatException) ? true : false)

The more complex case was like

	catch [netstandard]System.Object
	{
		IL_0010: castclass [netstandard]System.Exception
		IL_0015: stloc.1
		// ArgumentException ex2 = ex as ArgumentException;
		IL_0016: ldloc.1
		IL_0017: isinst [netstandard]System.ArgumentException
		IL_001c: stloc.2
		// if (ex2 == null)
		IL_001d: ldloc.2
		IL_001e: brfalse.s IL_0022
        ...

or, decompiled

	catch (object obj)
	{
		Exception ex = (Exception)obj;
		ArgumentException ex2 = ex as ArgumentException;
		if (ex2 == null)
		{
			NotSupportedException ex3 = ex as NotSupportedException;
			if (ex3 == null)
			{
			// ... throw on exhaustion
			}
			NotSupportedException j = ex3;
			Exception e4 = j;
			logException(store, e4);
			return result;
		}
		ArgumentException a = ex2;
		Exception e5 = a;
		logException(store, e5);
		return result;
	}

but now it looks like

	catch [netstandard]System.Object
	{
		IL_0010: castclass [netstandard]System.Exception
		IL_0015: stloc.1
		// object obj2 = ex;
		IL_0016: ldloc.1
		IL_0017: stloc.2
		// if (!(obj2 is ArgumentException))
		IL_0018: ldloc.2
		IL_0019: isinst [netstandard]System.ArgumentException
		IL_001e: ldnull // omitted in release
		IL_001f: cgt.un // omitted in release
		IL_0021: brtrue.s IL_0065
...
		IL_0065: ldloc.1
		IL_0066: unbox.any [netstandard]System.ArgumentException
		IL_006b: stloc.s 7

or in C#

	catch (object obj)
	{
		Exception ex = (Exception)obj;
		object obj2 = ex;
		if (!(obj2 is ArgumentException))
		{
			object obj3 = ex;
			if (!(obj3 is NotSupportedException))
			{
			// ... throw on exhaustion
			}
			NotSupportedException j = (NotSupportedException)(object)ex;
			NotSupportedException ex5 = j;
			bool store5 = store;
			NotSupportedException e4 = ex5;
			logException(store5, e4);
			return result;
		}
		ArgumentException a = (ArgumentException)(object)ex;
		ArgumentException ex6 = a;
		bool store6 = store;
		ArgumentException e5 = ex6;
		logException(store6, e5);
		return result;
	}

which discards the results of the isinst instructions, then does an unbox.any for any case that actually matches; which could provide a marginal space improvement, in the case where no clause matches -- i.e. another possible optimization the unhandled exception scenario; which in both cases are the "I don't care, this has just failed completely" route.

Friday, April 01, 2022

22Q1 Cycling

A milder winter than the last, with strong winds being the main feature; so a few longer rides early on, and storm-blown gaps in the record.

Late January snowdrops

January ended at 193.9 on the clock, or 116.1 miles for the month; February 314.2, meaning 120.3 miles for the month. March pushed the old bike to 611.1 on the clock (298.9 for the month including 2 off-meter), but the folder went to 78.5 (+11.9), and a new shopping bike clocked up 47.1, plus an unmetered 6.7 miles home for a total of 362.6 miles. Year to date, that's 601 miles, or about the same as last April.

Horse River Green

A burst of really warm weather near the end of the month allowed the first real exploration, rather than just pounding familiar nearby loops, this one exploring Cow Lane, from Linton to Great Chesterford, as a way of avoiding having to go as far as Saffron Walden to close the loop. Most of it is perfectly fine; but there's a section in the middle that suddenly went from dry to sodden, threading between ponds, and at times becoming indistinguishable from a river bed. Best for high summer, and from the Linton side, so the steep bit is downhill.

Saturday, January 01, 2022

Anime 2021

A generally disappointing year in all.

Spring season had a few "might watch" titles, but Crunchy picked up none of them, so I only picked up Odd Taxi, a noir-ish story of modern social-media driven ennui, which ends up being AOTY (long-form) pretty much by default.

Summer had the global release of Shin Eva, which was as much of a mess as it had seemed from original accounts, the painful and wildly mislabelled Fena, Pirate Princess (dropped after one episode of Fena being a vapid gold-digging whore), and Aquatope which began by looking like it would be cute girls doing cute aquarium things, with a little bit of low-key magic (from a local sprite wandering around in the first couple of episodes, and the occasional trippy underwater sequence), but rapidly turned into family drama and "welcome to the world of work", rather like Hanasaku Iroha, only without the bondage; and got dropped after 5 episodes.

Autumn brought just the tried and dropped Takt Op. Destiny, Sakugan and Digimon Ghost Game -- the latter being an episodic "urban legend kids' horror" series, a world away from Adventure, Adventure 02 and Adventure: that were a background to much of the year and now form an indistinguishable melange in my memory.

From the backlog, I went through Berserk in both '97 and '16 flavours, which passed some autumn evenings; but I still don't see what the fuss was about (except for the detailed crafting of the art in the original manga).

2H21 cycling

Ickneild Way, near Royston

In the second half of the year, I managed to do more each month than in 2020, reaching 2000 miles 21-Aug vs 29-Sep-20. At the end of November, I also managed to twist the frame on the old bike that had served me since '98, just shy of the 20,000 miles logged on that odo mark; and at the same time had odo problems on the newer bike, which just passed the 10,000 miles from new mark. Time to buy myself a present in the new year, I think.

As before, September was the high point -- monthly totals being July 361.1 (summer bike), August 504.4 (a little of the folding bike), September 609.9 (mostly summer bike) -- probably an all-time record -- October 429.1 (a dry month, this time, but mostly winter bike), November 309 miles (winter mostly, until written off), December 172 miles (including riding to both Christmas lunches I attended this year, much to the amazement of the others in the respective groups), for a total of just over 3700 miles for the year. The summer bike starts the new year with 77.8 miles on the (latest) clock, and the folding bike 66.5

While a lot of the rides were retreading old territory, I did a fair amount of exploration on byways, like taking the Ickneild Way most of the way from Royston to Baldock, even if many byways end up being just dead-ends; and from the ancient to the modern, making a lot of use of the new Girton to Fenstanton multi-use path in preference to the busway -- a very convenient fast route to places like the Golden Ball at Boxworth.

Henge, at Carriages, Fenstanton

The highlight of the year, though, was the opening of the long awaited Abbey Bridge, just before Christmas. Even if the Chisholm Trail itself is on the wrong side of the tracks for convenience (cycling it was only the second time in 40+ years living in the area that I'd taken the path across Coldhams Common), it means that I'll only use the Green Dragon bridge as and when I next visit the Green Dragon, which had been a regular location for pub lunch with former colleagues working on the Science Park, but alas such attendance has suffered under the continuing work-from-home regime.

Abbey Bridge, Christmas Eve, first full day of operation

Wednesday, October 13, 2021

F# and OpenSilver v1.0

An update to the previous series of posts following the first stable release of OpenSilver.

While the details of which lines of code in the Browser and Simulator projects need to be redirected at the F# types have changed since the earlier posts at alpha-7 release, the principle remains the same -- where the generated code refers to the C#/XAML App type, replace that with the derived F# type. The F# (logic) and C# (just the XAML, reified as abstract base types) are set up exactly as before.

If you're porting an old solution, from a pre-release OpenSilver, unless you've been staying on the bleeding edge, it's simpler to start by creating a new one, copying the F# project and the XAML project from old to overwrite the new, and otherwise starting from scratch, remembering to check in all the as-generated files before making the edits.

At this point, provided that all the repointing to the F# project and types is done correctly, it should all "just work".

There is one gotcha, though, that has appeared in the updates for publishing the Browser WASM since my alpha-7 exploration, in that some potentially very long file paths can now be invoked that point deep under the project's default obj subfolder. If your project is already down a few layers from the drive root it will run foul of the Copy MSBuild task which appears to still labour under the old DOS MAX_PATH of 255 characters. Copying to an overlong path fails by timing out, so breaking the build. In that case add

    <IntermediateOutputPath>shorter file path here</IntermediateOutputPath>
    <BaseIntermediateOutputPath>$(IntermediateOutputPath)</BaseIntermediateOutputPath>

where a suitable up-tree location is specified e.g. starting at the top of the repo, or in a shallow build output directory outside the repo, rather than as a child of a project directory. Note that both values need to be set and aligned, lest defaults be assumed during the process.

The resulting code can be found here.

Tuesday, July 20, 2021

Lemon Cheesecake recipe

Delving through a mass of old paperwork for more mundane things, I found this in passing, dating from 1960s Autralia

Case: 8oz digestive biscuit crumbs + 4oz butter melted and pressed into the pie dish; chill in fridge.

Filling: Mix 2oz whole milk and 4oz cream cheese into a smooth mix, add ½ can condensed milk (about 200g) and ¼ cup fresh lemon juice (about 2 lemons) and 1tsp vanilla essence. Fold in a small can of cream (about 100g), and pour into the case.

Leave in fridge overnight, and sprinkle with freshly grated nutmeg before serving.

I've not made this in ages, but it was always a hit.

Thursday, July 01, 2021

Q2 Cycling

April was cool but dry -- only one "maybe thinking of spitting" in the whole 30 days event; and concluded with the re-opening of both the Coton footpath bridge and the jetty at Ditton Meadows, both of which I covered for the last ride of the month. At the end milage totals were winter bike 17954.3, summer bike to 3640.4 and then a battery change ending at 136.3 for 288 miles for the month.

May blossom in April

May was cool but also wet -- the usual rainy season -- though it did end with a burst of hot weather that just beat out March for hottest day of the Spring; concluding with a 48 mile ride through the fens to Wicken and Upware. The totals were 18268.3 and 136.3, for a total of 314.4 miles

Those wind turbines at close quarters

June's weather went downhill towards the end -- see the gap -- but that didn't stop me ending the month at 18718.5 and 136.3 for a total of 450.2 miles (just short of June 2015's total, but best month since), and 1319 for the year, after exploring more new cycle routes along the A14 which make for conveniant 20-mile level rides, and also going across the A11 at the Wilbrahams to explore a by-way that runs close by the foot of the wind turbine installation visible for miles around.

Monday, May 03, 2021

F# under the covers XVIII -- lambdas and closures

Consider this code, using named and anonymous inner functions

  let F1 l =
    let aux i = i + 1

    let FI li =
      let rec FII lii acc =
        match lii with
        | [] -> acc
        | x :: xs -> FII xs (aux acc)
      FII li 0
    l |> List.map (fun i -> (string i).Length)

The inner functions are compiled as FSharpFunc objects, with values closed over being injected as constructor arguments.

Before .net 5.0.200, this would make function F1 look like

public static FSharpList<int> F1<a>(FSharpList<a> l)
{
	FSharpFunc<int, int> aux = new aux@9();
	FSharpTypeFunc FI = (FSharpTypeFunc)(object)new FI@11(aux);
	return ListModule.Map<a, int>((FSharpFunc<a, int>)new F1@17<a>(), l);
}

With .net 5.0.200, the fact that some of the inner functions -- like aux above -- are pure, closing over nothing, has been taken account of, and needless new object creation is avoided, in the same way that C# lambdas have long been cached after first use.

public static FSharpList<int> F1<a>(FSharpList<a> l)
{
	FSharpFunc<int, int> aux = aux@9.@_instance;
	FSharpTypeFunc FI = (FSharpTypeFunc)(object)new FI@11(aux);
	return ListModule.Map<a, int>((FSharpFunc<a, int>)F1@17<a>.@_instance, l);
}

where the aux and F1@17 functions -- the latter being the anonymous function used by List.map -- are referenced through a class internal static readonly value, rather than having to create a new instance every time.