David Vedvick (Notes Feed)

Double the taskbar size... . necessary?

2009-03-02T17:43:35.000Z

Double the taskbar size... . necessary?

So I'm thinking of going double the size for my taskbar in Windows 7. Worth it? I don't know yet, it's my experiment in usability.

Exciting Stuff

2009-08-18T01:36:53.000Z

Exciting Stuff

Working on exciting stuff here in the batcave. The new computer configuration doo-hickey is now available and is 99% complete. Go ahead and test it out, build a computer, have fun. Order one, if you like, as well.

Space Shuttle Launch

2009-08-25T02:21:08.000Z

Space Shuttle Launch

The launch of Space Shuttle STS-128 is about to take place. This is going to be a night time watch, and these things are always the coolest to watch. Although day time ones are cool too. I highly recommend watching one of these if you never have. I would like to see one live myself.

Windows 7 RTM Coming Up

2009-08-29T02:53:34.000Z

Windows 7 RTM Coming Up

NDSU has had the kind heart to loan me a Windows 7 key for personal use. Hopefully it turns out. I'll try to get back to everyone on the quality of Windows 7 here in a bit. A few words though, before the installation occurs. I'm currently using Windows 7 RC (Release Candidate), and I can say that it is rock-hard stable. The only place, in my mind, that the Release to Manufacturer's release has is to go up. In other news, I'm listening to 'Abel' by The National, and it's awesome.

Firefox Useability Enhancements

2009-08-29T20:16:00.000Z

Firefox Useability Enhancements

So we've all been enchanted by the simplicity and usability of Google Chrome, correct? Well, if you haven't, then I highly recommend downloading it. However, overall I prefer many of the features of Firefox, and even some of the UI decisions of the open source browser, so I prefer to use it for my everyday browsing needs. Even so, I find myself missing Google's Aero Glass integration and such. So I decided to look for ways to integrate some of these with Firefox's add-on support. Here's my list of what I added to make Firefox more usable by today's standards:

Firefox "Windows 7 Remix" theme:

I installed this theme that emulates the proposed Firefox 3.7 "Windows 7 Remix" theme perfectly. You also have to install the All-Glass Firefox Add-on, which allows Firefox to use the Glass effect present in Windows Vista and 7. Makes browsing look much nicer.

Personal Menu

This plug-in lets you get rid of that space-consuming menu-bar and replace it with a few IE7/8/Chrome-ish buttons. On top of that, you can even edit the personal menu and add your own menu items from the aforementioned traditional menu-bar to it.

Speed Dial

Speed Dial has been around for awhile. Basically allows you to have a similar Speed dial page to the one in Opera show when you open a new tab. Useful, similar in concept to the bookmarks bar.

Tabs Open Relative

The final Chrome-inspired add-on that I added was the simple "Tabs Open Relative". All it does is make links that open a new tab open the tab directly to the right of the originating tab. Find it here.

Feeling a little inspired by Win7 I was when I was searching for an Aero Peek-ish add-on that would show my current Firefox tabs in the Aero Peek tabs in Windows 7. Well I couldn't find any add-ons, but this tab preview add-on helps out, at least.\

A tip

I would also like to add a tip this list to give you even more browsing space: get rid of that worthless status bar at the bottom of the browser. Just go to 'View' in the menu-bar and uncheck "Status Bar".

The Final Look:

** Well, there it is. Hopefully, this post will be useful to anyone, including my customers, in making a better looking, more useful browser out of Firefox. If you would like to see more posts like this, let me know in the comments section. Later, David

Ordering a Computer on DeVed Computers

2009-09-02T02:51:45.000Z

Ordering a Computer on DeVed Computers

As some of you know, I've recently created an application for DeVed Computers (found here), that allows you to either pick from a computer created ahead of time or to create your own. I've had this up for a couple of weeks, and have since kinda taken a break from all DeVed Computers related stuff (except for building and troubleshooting/repair computers, of course). While I have tried to make this web app as self-explanatory as possible, it is probably still helpful for some to see a tutorial straight from the creator, so here goes:

Step 1: Pick needs that reflect what you want to do with this computer

In this step, you check the boxes for things you want to do with your computer. While I've tried to add as many needs for a computer as possible, there's a very good chance I haven't added them all yet - if you think of one, contact me at contact@devedcomputers.com and let me know.

Step 2: Enter a Budget for your PC

In this step, you set a top limit on what you want to spend on a new PC. If there are existing orders in the DeVed Computers COSAS Database that reflect your needs, they'll only show if they're under or equal to the budget you set (nifty, huh?)!

Step 3: Buy a PC that's already been ordered from DeVed Computers or Create your Own

Here, you can select a similar PC to yours that was previously ordered from a user whom had selected needs and a budget at your level or lower, if you wish. If you choose to do that, proceed to Finishing ordering your computer below.

Otherwise, go ahead and click the 'create your own PC' link below the pre-configured PCs, and proceed on to the next step!

Step 4: Select a case

So now that you've chosen to create your own PC, the web-app has found some cases that fit your needs. If you move your mouse over the item, you will see the item description and the price of the case. After selecting your case, go ahead and click the 'next' arrow.

Step 5-10(ish): Configuration

Complete the rest of the steps - don't worry, the app figures out the compatible items for your computer, so just pick the items that fit your budget and with the features you want.

Step 11: Finalizing your order

Now please take a moment to review your order. If you see an item you don't want, or decide you want to change something, just go ahead and click on an item to change it!

Step 12: Link your order to a username

Now you can go ahead and link your order to a username. Don't worry, I don't ask for a name or address, this is just so I know who ordered that fancy computer. Name and address get asked for later by PayPal (who has secure storage for your credit card information).

Last Step: Add your computer to the PayPal Cart

This last button leads you to the PayPal cart. From there, PayPal will take care of you.

The Last Last Step:

Finally, if your payment goes through, your parts will be assembled and your customized PC will be shipped to you in under 3 weeks!

Computer stickers/Case Badges

2009-12-26T17:23:46.000Z

Computer stickers/Case Badges

Well now that school is hopefully done, I have plenty of time to post random stuff. Check out these cool "case badges" I bought a few months ago:

Just did Java, on to C#

2011-03-20T23:14:06.000Z

Just did Java, on to C#

After the Java project that saw limited success with our client, I'm moving on to a new project in which I'll be coding in C#. Should lend me some new, valuable experience.

Starting up the development blog

2011-07-15T03:42:17.000Z

Starting up the development blog

So, I used to write... alot. Truth be told, I had a lot more time on my hands. I also had a lot of sad teenage/college experiences to talk about. I'd like to think I've matured a bit since then, and also, since then, gained a bit of brain power (although a night at the bar's can erase that brain power a little bit). Anyways, I plan to use this space to talk about software development, and the lessons I learn from it. The main thrust of this blog will be, as it has been for quite some time, DeVeD Computers (name-change and new look coming soon, or at least within the next 30 years hopefully). I am also thinking about starting up a resume page, for information about yours truly.

A guide to initialization logic

2011-07-17T15:40:13.000Z

A guide to initialization logic

I have seen many a programmer make some basic logic mistakes that could save them a lot of time and cleanliness. The simple case is this: Let's say you want a = 5 when "condition" is true, and a = 4 otherwise. Below may seem the obvious way to do it:

    if (condition is true) {
        a = 5
    }
    else {
        a = 4
    }

Now, there is nothing wrong with this in a basic scenario. However, if you have other nested if's where it must equal another number, it can get confusing. So let's make our conditions more complicated. Let's say if George is 5, we give him 5 apples. If George is 6, we give him 7 apples. Otherwise, we give him 4. Using the above logic and extending it, we end up with something like this:

    if (George == 5) {
         apples = 5
    }
    else if (George == 6) {
         apples = 7
    }
    else {
         apples = 4
    }

Once again, nothing implicitly wrong in this scenario. However, what if the age we're given for George is, say -1? Let's say, for our robust apple giving programming language, that this results in an impossible age exception. Thus, we must try and catch this language now:

    try {
         if (George == 5) {
              apples = 5
         }
         else if (George == 6) {
              apples = 7
         }
         else {
              apples = 4
         }
    } catch (AgeException AgeExc) {
         apples = 4
    }

Here you can see the cracks in using the above logic where you set apples = 4 after you confirm no other scenario is true. You have to now set apples = 4 twice, unless you prevent this exception from occurring. This would would like this:

    if (George == 5) {
         apples = 5
    }
    else if (George == 6) {
         apples = 7
    }
    else if (George < 0) {
         apples = 4
    }
    else {
         apples = 4
    }

So, different code, same result, apples has to be set to 4 in two different conditions. I could go on with examples much more complicated than this, but I will save you the time and present you a much simpler solution to the problem: initializing apples to 4 at the beginning of the program. So, if you set apples = 4 at the beginning of the program, what does our code now look like? With the try catch block:

    apples = 4
    try {
         if (George == 5) {
              apples = 5
         }
         else if (George == 6) {
              apples = 7
         }
    } catch (AgeException AgeExc) {
    }

Without a try catch block:

    apples = 4
    if (George == 5) {
         apples = 5
    }
    else if (George == 6) {
         apples = 7
    }

You can see here that we've reduced the complexity of the program substantially, while reducing the programmer's risk to the otherwise apples value changing in the future (let's say we want to give George 10 apples when he's not 5 or 6 in the future), by only providing one area where the default value for Apples would need to be changed. While the logic may seem less straight forward, it just requires a different way of thinking: You must say, instead of "if George is 5, we give him 5 apples. If George is 6, we give him 7 apples. Otherwise, we give him 4", "George will get 4 apples no matter what. However, if he is 5, we will instead give him 5 apples, and if he is 6, we will instead give him 7 apples". This has saved me many a time in the past from some pretty basic programming defects that could have been avoided if the amount of logic and amount of initialization had been reduced.

Neat story on some of the lost disciplines of programming

2011-08-06T23:40:13.000Z

Neat story on some of the lost disciplines of programming

http://www.itworld.com/print/190213

jQuery UI sort on hidden table rows

2011-10-03T01:10:50.000Z

jQuery UI sort on hidden table rows

jQuery UI's sortable works great on tables in the newest version, 1.8. I've been using it for some pretty interesting sorting of data involving complex parent child relationships, where one row may have children directly below it. However, I recently had a major issue, where rows were flickering when you would try to move them and the placeholder would continuously jump down to the second to last row. This was very confusing, as I had done many more complicated things with table sorting in IE8. After 5+ hours of troubleshooting that I won't go into, but will reassure you, was quite frustrating, I finally had revelation after I stepped away from my computer: hidden rows were in the table, and these were causing the conflicts! jQuery UI sortable calculates the position of your sorting row by first getting the height of all the rows that can be sorted. If your table is like so:

    <table>
         <tr><td>Row 1</td></tr>
         <tr><td>Row 1</td></tr>
         <tr style="display:none"><td>Row 3</td></tr>
         <tr><td>Row 4</td></tr>
    </table>

You will discover that, at least in IE8, your table sorting will not work work as expected. You will see various flickering issues and rows being dropped in the incorrect places if you just do a basic jQuery UI sortable declaration: $('table').sortable(); Instead, what you will need to do is a slightly more clever declaration: $('table').sortable({items: 'tr:visible'}); This will only sort on the currently visible rows. This worked really well and only involved a small code change to implement the change. Hope this helps others if they are implementing jQuery UI's sortable on a table.

Moving to CakePHP

2011-10-03T02:38:28.000Z

Moving to CakePHP

Well, I think I'm just gonna pull the plug and move my current development on DeVeD Computers to CakePHP. Having a well done framework really does decrease development time, instead of worrying about simple things like proper page routing and whatnot. Maybe I'll first branch development on my server....

SharpXML

2011-10-24T00:53:55.000Z

SharpXML

So this weekend I made an XML parsing Library called SharpXML. Basically, all of the XML Libraries that come with MS's standard .Net implementation seem to me to fall very short of ease-of-use, which is something I value highly when developing. I could write more about it, but in short, what it really means is I need to get a life :). Here's the link to get it: http://sharpxml.codeplex.com/

Expanding or changing the business...

2012-05-07T14:37:52.000Z

Expanding or changing the business...

So, now that I've had some free time, I've been thinking deeply about the business model I chose way-back-when I decided to open a boutique computer shop. Obviously, the market is not huge here, and to make a dent, I need to do something different than what I currently do. This puts a major roadblock in further developing my website... maybe. Or maybe not ;).... Either way, I've gone forward with CakePHP 1.3, and development has been easier than even I anticipated. Really slick framework for PHP.

New version of J. River Media Center Windows 7 Integration plug-in released

2012-06-10T19:24:50.000Z

New version of J. River Media Center Windows 7 Integration plug-in released

A new version of my Windows 7 integration plug-in for J. River Media Center has been released. Notable fixes include:

Memory Leaked fixed on preview when Thumbnail Cover Art is enabled.
Thumbnail Cover Art properly re-sizes to thumbnail size.

It can be downloaded from the Google Code site I set-up for it.

I will detail the memory leak fix in greater detail a little bit later, as it was quite interesting... **

Download: http://code.google.com/p/j-river-media-center-windows-7-shell-integration/downloads/list

Version 0.9.2 of J. River Media Center Plug-in

2012-06-10T23:25:29.000Z

Version 0.9.2 of J. River Media Center Plug-in

I guess I've been bored today :).... I posted a new version to Google code. Notable fixes include: Fixes:

Thumbnail Previews
- Improved initialization of the Thumbnail Preview
- Improved handling of Minimize scenarios Check it out at Google Code

Version 0.9.3 of J. River Windows 7 Integration Media Center Plug-in

2012-06-13T20:48:26.000Z

Version 0.9.3 of J. River Windows 7 Integration Media Center Plug-in

Version 0.9.3 of J. River Windows 7 Integration Media Center Plug-in is out today! I posted the new version to Google code. Notable fixes include: Fixes:

Regression: Pause now changes progress to yellow as before
Regression: Waiting status now changes progress to indeterminate (cycling progress bar without begin or end)
Correct Version Number in installer Check it out at Google Code

Oracle 10G and Parentheses

2012-10-11T03:57:08.000Z

Oracle 10G and Parentheses

A word of warning to all who are still stuck with using Oracle 10G 32-bit in a 64-bit environment: _Do not install your programs in a path where one of the folders has parentheses in it. _ So, in other words, the most common 32-bit install path, "C:\Program Files (x86)\.." is unusable if you have an app that uses Oracle 10G 32-bit. Oracle cannot handle this situation, and is unable to even complete a TNS Look-up and make a connection. Bleh.

Music Streamer for J. River Media Center on the way

2012-11-05T03:29:34.000Z

Music Streamer for J. River Media Center on the way

I'm building this with the goal of improving upon and/or pushing J. River to improve their own media player for Android. It's in a _very early _stage of development. Here's some screenshots :) [gallery columns="2"]

A eulogy for a man I didn't ever know...

2013-01-12T19:21:02.000Z

A eulogy for a man I didn't ever know...

Today it has been reported that Aaron Swartz has committed suicide. I never really knew who the guy was, but his credentials were amazing, and I think this is one of those things where you don't realize what your world (my world consisting mostly of technology) had until you have lost that asset. Aaron Swartz was an incredible mind; he developed the early version of Reddit, he was a co-author of the original RSS 1.0 feed (which my blog and every blog uses), he helped develop a L__egal document (Creative Commons 1.0), and he had released tons of scientific data to the public. He committed suicide today, and we now will never know what else he could have contributed to our world, and to mine in particular.

NearlyFreeSpeech.net

2013-02-09T00:38:24.000Z

NearlyFreeSpeech.net

It seems like it's been forever since I switched to NearlyFreeSpeech.net, and while it may reflect poorly on the amount of readers I have, I have to say I love the pricing model, and the speed that their servers run at!

The new deliciouspc.com (the site formerly known as DevedComputers)

2013-02-11T06:10:40.000Z

The new deliciouspc.com (the site formerly known as DevedComputers)

I have "officially" launched my new computer business website, delicious pc. It's currently in a bit of a rough state, but I was so pleased with how everything was coming together that I couldn't help myself and so I published it to deliciouspc.com. Here's a little run through of the site: The homepage: Selecting needs:

Inputting your budget:

And the final page! You're already done. Wasn't that easy? I'm sure there are some parts that won't work (I just discovered the e-mail option isn't working at the moment), but overall it seems to be in a decent alpha stage. UPDATE: I just got the e-mail option working again. Back to android development soon!

Android Media Streamer App Progress

2013-03-18T02:55:16.000Z

Android Media Streamer App Progress

For some reason, programming in Java makes me feel like blogging. I think it's just the monumental amount of work involved in getting some of the basic things done that makes me particularly angsty (don't get me started on setting up your own events). Anyways, I've made some decent progress:

The state machine logic to get the Service to pre-buffer the next file to be played in a playlist in a background thread
The connection has some fault-tolerance so that if you move away from your local network it tries to get the remote URL and connect to it
Album art now displays in the Now playing dialogue
The notification changes with the album My next steps:
Add playlists as a "Category" to browse like the normal categories (whatever is set in the Media Center configuration)
Add the ability to choose different play modes on a "long-click" of any item that is not a category
Add play controls
Add progress indicator
Make sure you can start a different playlist if you choose to (I'm afraid to test this out ;)) Sorry for any wild grammar or spelling mistakes, my heads kind of throbbing :-/

"JR Media/Music Streamer" screenshots...

2013-03-27T02:15:06.000Z

"JR Media/Music Streamer" screenshots...

Some work in progress screenshots.... Todo:

Add a button to go to "Now Playing" when it's not playing but is paused
Save the state of the app to local (NAND) memory when the music is paused and the garbage collector comes around
Improve the look.

"Project Blue Water" - formerly known as "Media Streamer" progress

2013-08-12T12:03:51.000Z

"Project Blue Water" - formerly known as "Media Streamer" progress

Major improvements have begun to the UI of my media streamer project for J. River Media Center, which I'm now giving the name "Project Blue Water". First and foremost is the "Now Playing" UI, for which I've taken some new screenshots, to be loved or hated: As you can see, I've also added the ability to change the rating on a song!

My (slightly (un)qualified) thoughts on Windows

2013-09-02T01:06:49.000Z

My (slightly (un)qualified) thoughts on Windows

In the court of public opinion, the jury has ruled on Windows 8. It has become clear that the drastic changes in UI without any instruction to the user or any way to change it back has had a negative effect in the uptake of Windows 8. And after I installed Start8 and Modern Mix it has finally become clear to me that either Microsoft has plans that we aren't aware of yet or it has completely missed some massive potential here. If you aren't aware, Start8 restores the Windows start menu. It uses an icon that is similar to the icon from the restored Start button in Windows 8.1. Modern Mix is unique in that it adds the ability to run the Modern UI apps in a Window. This effectively restores Windows 8 to a Windows 7-like desktop UI. Surprisingly, it all works really well - and more than anything, it actually makes me want to start using Windows 8 on my laptop. Modern Mix makes those beautiful Metro Modern UI apps usable without having to mess with the start screen, and with the ability to quickly switch to my normal Windows apps using my normal workflow. This tells me that at least I personally would have loved my purchase of Windows 8 if the following things had been done: When in laptop mode (i.e. with a keyboard/mouse):

The Windows 7 start menu, in the style of Windows 8 (or even a slightly improved one)
No "start screen"
No "charms"
The ability to use Modern UI apps on the desktop When in a "tablet mode" (i.e. no keyboard/mouse), enabling all the UI changes that Microsoft introduced with Windows 8 are fine, and even great. On top of this, to add on some nice-to-haves, when using my software on a Theater PC, I think these things would be nice:
The start button on an MCE remote should bring up the Start screen (yes now I like it)
Metro apps should have an easy ability to tie-in with and use an MCE remote On a side note, the Start screen actually works really well with the MCE remote once it is started, and adding a registry change to map the Start Screen to the Start button is not as hard as it sounds.

Version 0.9.4 of Windows 7/8 J. River Integration Media Center Plug-in

2013-09-02T16:00:07.000Z

Version 0.9.4 of Windows 7/8 J. River Integration Media Center Plug-in

After a long wait, a new version of the Media Center plug-in is out! It can be downloaded here and as you can see, I've added basic Jumplist support for Playlists: Here's the official changelist: New:

Playlists can be pinned in the jumplist Bug fixes:
Config reverts upon installing a new version of Media Center
Window Title text in preview will not truncate to "J River Media Ce" (Thanks StFeder from the J River forums) As this a new release, I am not yet removing the 0.9.3 version until any stability issues are sorted out. Download link.

Windows 8.1 Upgrade - potential hard drive killer?

2013-10-19T23:50:20.000Z

Windows 8.1 Upgrade - potential hard drive killer?

Upgrading from Windows 8 to Windows 8.1 has already taken two victims. Will it take more? Word of warning to those upgrading their Windows installs to Windows 8.1 this weekend - I installed it on my (7-year old) 250GB RAID 1 array and it thrashed and killed both drives. So lookout! Obviously it being an older pair of drives, I can't speak to the reliability of them, but it does seem very odd that they would both suffer from SMART errors on the same day. Otherwise, on my other machine Windows 8.1 seems to be working fine.

The Promise of Google Voice

2014-01-12T15:08:55.000Z

The Promise of Google Voice

I have just recently decided to drop my phone contract. I'm not dropping a contract completely - I'm making the incredibly tempting switch to T-Mobile's no annual contract, which won't include an ETF that will kill me if I decide to switch again. However, I hit one major snag while making this switch. I couldn't use my old North Dakota number as T-Mobile doesn't have 1st-party coverage in Bismarck, ND yet. My alternative would have been to go with AT&T or with their MVNO, AIO wireless, which offers comparable plans to T-Mobile. However, I'm still fairly apprehensive of AT&T and their death-throe business tactics. In the end, I chose T-Mobile. So how does this play into Google Voice? My solution ended being that I would use T-Mobile, but use Google voice as my number. The potential of this solution is amazing: without a number that is tied to a phone service or contract, but rather just to me, I'm able to easily pick up a prepaid SIM from AT&T when I need some minutes in North Dakota, and just assign the number with the SIM to my Google voice account. I really hope that as Google starts to move more out of working on building the structure for an open handset into providing the services on that handset that they come back to Google Voice and really start to sell this potential to customers.

Latest Project Blue Water Updates

2014-04-08T03:41:47.000Z

Latest Project Blue Water Updates

I've made numerous improvements to Project Blue Water. I'm feeling a little too lazy to write about it extensively, but below are new screenshots. Slideout drawer

An ideal SPA

2014-05-19T12:16:12.000Z

An ideal SPA

An ideal SPA should have its initial state on load pre-rendered from the server. After this, the client-side JavaScript should be able to take over all duties.

Ridiculous

2014-06-05T12:22:39.000Z

Ridiculous

It's absurd to think that we can afford to stream HD video from space but somehow Comcast can't afford to upgrade their equipment to stream episodes of mad men competently.

Stop using my documents folder

2014-06-11T18:08:33.000Z

Stop using my documents folder

Game developers, please stop using my "Documents" folder to preserve the state of your video games. This is annoying at best and worst case, destructive. Here's my random list of why:

It eats up space on an area that I might have specifically set-up to not use space (since it is only supposed to be documents and all)
There's a better place for preserving the state of a program in Windows; it's under /AppData/... notice the "AppData" in the folder path?
It adds unnecessary data and/or configuration steps when I synchronize my personal, you know documents
Like the above point, it requires extra configuration in a back-up tool that I may use for backing up my documents to exclude your information
- And don't think that just because I am playing your game, I care to back-up the game data!
  - And if I do, and I already know how to use a back-up service, I will configure it do that myself!
It puts a bunch of folders in my documents folder referencing gaming companies. I don't see you putting your video games in my filing cabinet, WHY IN THE HELL IS IT IN MY DOCUMENTS FOLDER?!
Finally, usually the data isn't even frickin' documents! Take a look at Sid Meier's Civilization 5:

Civilization 5 Cache is somehow in my Documents folder

Note above how the _cache_ is stored in my documents folder. Do you think a _cache_ is something I would store in my documents, Sid?

SpaceX launch

2014-08-05T05:22:01.000Z

SpaceX launch

Great post on "starting from scratch"

2014-08-23T21:17:31.000Z

Great post on "starting from scratch"

This is a great post on "starting from scratch". It's pretty old and I've probably come across it before, but it's a good one.

Coming soon!

2014-08-30T04:45:34.000Z

Coming soon!

I'm glad

2014-08-31T02:21:51.000Z

I'm glad

I don't have this problem yet.

Installing MonoDevelop on Linux

2014-10-31T03:51:17.000Z

Installing MonoDevelop on Linux

Today I discovered the joys of "installing" as it were MonoDevelop on Linux. All it took was pulling down from Git, getting all the dependencies (non-trivial) and doing a full build. And then there was something to do with adding a key of some sort before I could finish the build - since NuGet needs some keys of something or other. Either way - I'm up and running and boy is it fast compared to Java's equivalent (as far as I know), Eclipse. Still running into some issues getting MVC.net up and running, but it looks like I'm not the only one. Here's the Linux fix since that was a Mac fix.

A (color) change is gonna come

2014-12-20T04:34:51.000Z

A (color) change is gonna come

Coming even sooner! Without the sepia/night time shading.

Clearstream, the project formerly known as blue water

2015-01-02T00:37:37.000Z

Clearstream, the project formerly known as blue water

It's a new year, so I have some new screenshots of Clearstream, the project I used to call "project blue water". I'm closing in on the final feature set for Clearstream before I release it to the public - only one item left on my list: Last.fm support. [gallery ids="1340,1339,1338"]

Clearstream on a Tablet

2015-01-14T23:39:47.000Z

Clearstream on a Tablet

Clearstream on a Nexus 7 (2012)

Clearstream (name subject to change) Beta is out!

2015-01-24T22:12:45.000Z

Clearstream (name subject to change) Beta is out!

I'm proud to announce that Clearstream is ready for a beta release. I initially will be providing it as a download that you will have to install manually. It currently only supports Android 4.0.3+. I also plan a release of the source on GitHub or some other Git hosting service at some point soon. It's a fairly straightforward app that is intended only for streaming music from J. River Media Center. It's main goals are improved streaming reliability and better usability. I intend to write at least a crappy attempt at a tutorial for using it, but until (or if) that happens, you can look up previous posts to get a hint of how to use it. The main UI "trick" that users will need to be aware of is that many list items will show a menu if they are long pressed. Update: Please use the most recent version of audiocanoe. [gallery size="medium" ids="1356,1357"] If you've never installed a third-party app before, there's very many good tutorials to set you up. Here's one.

Clearstream 1.0-beta features

2015-01-25T04:25:45.000Z

Clearstream 1.0-beta features

Stream music from server with high reliability
- Will use local music files if they exist and the filename and metadata match
- Modern interface
- Updates server with now playing information
- Interfaces with Bluetooth remote control clients and Pebble watches
- Interfaces with apps that implement the Scrobble Droid interface (Simple Last.fm Scrobbler is my scrobbler of choice) for scrobbling to Last.fm or Libre.fm
- And more....

I have had a sustained switch to Linux

2015-02-08T19:11:55.000Z

I have had a sustained switch to Linux

After many years of fits and starts, I have finally stayed on a Linux distro for many months. What conditions enabled this change?

I spend much more of my time just programming these days when I'm on my PC than doing entertainment tasks (i.e. watching movies, playing games)
- Except for Visual Studio, many of the same tools I use for programming are available on Linux
Steam was made available for Linux, and most importantly, Civ 5 was ported to Linux, so when I do game, I can play the game I like playing most on my PC
Linux Mint came out with a, shall we say, "normal" or perhaps "traditional" user interface, and is rock solid
As a bonus, the Media player program I've used for years, has come out with a Linux port that's in development
The open source driver for AMD cards has really grown into its own Overall, I'm loving it!

Mutability

2015-02-22T16:58:30.000Z

Mutability

Was mutability the cardinal sin of high level programming languages?

Clearstream 1.0.0.2

2015-03-08T14:37:00.000Z

Clearstream 1.0.0.2

Hey everyone, I've released a new version of Clearstream, Clearstream 1.0.0.2. Feature-wise, it's the same as the previous release (I will likely bump the minor version number up if I add a new feature). This is still what I would consider a beta release, but the code has reached a point where I'm comfortable releasing the code to the general public.

First, the download

Update: Please use the most recent version of audiocanoe.

To the code: Clearstream code will be released under the Lesser General Public License (LGPL) 3.0, meaning you can fork the code and change what you want, but any derivative works must be released under the LGPL or a more restrictive license (such as the GPL). Further, if you use parts of the code as a library (for whatever reason you would want to do that?), you can use it in software with any license, as long as you give me credit! I'd suggest you post any issues here.

Wilco streaming clear

2015-03-10T04:22:36.000Z

Wilco streaming clear

Tweedy + clearstream

Clearstream 1.0.0.3

2015-04-06T03:55:29.000Z

Clearstream 1.0.0.3

Hey everyone! Clearstream 1.0.0.3 is out! I mostly focused on making the UI consistent across the board. No doubt there are some areas that are still inconsistent however. Here's a list of the fixes/changes:

Search activity filters on audio file type
Pressing "back" button when a context menu is open reverts context menu to list item first
Clicking on an item in a context menu reverts the context menu to the list item first
Clicking on a file no longer plays it
Added small tutorial

Download here: Update: Please use the most recent version of audiocanoe. If you've never installed a third-party app before, there's very many good tutorials to set you up. Here's one.

"audiocanoe" - the alternative JRiver Media Center audio streaming client for Android formerly known as Clearstream

2015-05-24T17:05:51.000Z

"audiocanoe" - the alternative JRiver Media Center audio streaming client for Android formerly known as Clearstream

"audiocanoe", the alternative JRiver Media Center audio streaming client for Android, formerly known as "Clearstream", has been updated. The biggest update in this release is an improved "File details" view:

An update: If you prefer downloading and installing from Google Play, along with all the benefits that provides, you can join the "beta" as it were by joining this Google+ group (annoying, I know, I think if/as soon as I decide to promote it to production, I'm going to disband the beta group). You can also try this direct link to the play store, but I think it's going to ask you to join the group first.

New Personal Site Setup

2015-06-26T15:32:31.000Z

A New Personal Site Setup

Finally, I have gotten off of wordpress and migrated my site to a nodejs/ReactJS custom set-up that statically renders markdown files.

How I Built My New Site

2015-07-27T01:42:22.000Z

How I Built My New Site

Long ago, shortly after I had started hearing about React on Hacker News, I came across a post that suggested that it was fairly trivial to build a blog (or any website in general) with ReactJS and NodeJS, and that you could not only have dynamic routing and client-side rendering, but also render views statically server-side.

Architecture

For years, I had been hearing the outcry about Wordpress (usually related to it's unnecessary complexities and security faults), and had for the most part, agreed with them. So, for a while I fiddled around with NodeJS and ReactJS for a few months and finally reached a breakthrough point where I really felt I had the knowledge to build this site by hand, and hopefully, get a good introduction to this new ReactJS thing, and this old (but totally new to me) thing called NodeJS.

The stack I chose is fairly standard:

expressjs for the routing
express-react-views for displaying statically rendered ReactJS views
ReactJS for the front-end views
GulpJS for build and deployment

To reduce processing time in my release environment, most of the pages are rendered and built once in my GulpJS deploy task to an HTML file using ReactJS's React.renderToStaticMarkup method (this avoids a render method on every request, and allows browsers to cache more). This page is the exception, of course.

Development

Building the site was just a develop/refresh cycle, with what I would assume is fairly vanilla ReactJS, so I won't bore you with the details. GulpJS, along with a watch task, provided extroardinary amounts of help here.

Deployment

Once development was finished and it had a style that I enjoyed (simple does it!), I began focusing on deployment. I currently use nearlyfreespeech as my host provider, and I decided to stay with them if I could. Luckily, nearlyfreespeech hasn't stood still since I started hosting with them in 2012, and they have since enabled the usage of long-running processes, and proxies to connect them to. Of course they would also have the most recent version of NodeJS and NPM installed.

The downside to nearlyfreespeech's current pricing model with continuous running processes is that Node can tend to be fairly resource heavy.

For deployment, I fell back on GulpJS again. Unfortunately, there was not any first-hand support for SSH in GulpJS, so I used a plug-in called, aptly enough, gulp-ssh (notice the pattern here?). This plug-in competently handled connecting to SSH, however it was fairly limited in how it sent files - it only allowed files to be sent one at a time.

What I wanted was an SSH version of gulp.dest. I ended up adding a prototype method to gulp-ssh that did exactly that, called using gulpSsh.dest. I still have my doubts as to whether that functionality should exist independently in a separate plug-in, perhaps called gulp-ssh-dest, or something similar, operating in the spirit of Gulp. For now I will leave it as is, and perhaps come back to it later if I decide to make a separate plug-in which just covers that functionality.

You can view the source for the site on my github. My updates to the gulp-ssh plug-in can be reviewed and improved as well.

When the Boss comes on, it's gonna be good

2015-08-08T21:06:40.000Z

When the Boss comes on, it's gonna be good

When the Boss comes on, it's gonna be good

Nifty SQL

2015-08-15T13:26:38.000Z

Nifty SQL

It's a very rare thing when neat code is also useful; in my experience "neat" or "clever" code usually also comes with some major caveats: readability and maintainability, and usually arguable usefulness being the major ones.

However, I think the self-join solution to the "greatest-n-per-group" problem might be one of the exceptions to that rule. While it certainly suffers from a lack of readability (at least personally, it requires a few mental acrobatics to comprehend), it makes up for it in its usefulness and execution speed; since it generally can work on indexes, it can avoid expensive index and/or table scans!

Really, quite a clever solution. I wonder if there's a mathematical analog to this solution?

Custom SQLite Access Difficulties in Android

2015-09-23T12:11:57.000Z

Custom SQLite Access Difficulties in Android

It is surprisingly difficult to access the SQLite database that the Android API exposes in anyway that is not using Android's native APIs. There's certainly no native JDBI wrapper supplied.

This is unacceptable for me; mapping fields to database fields by hand is something that we have automated numerous times in the last couple decades. The Android API does not do this. SQLite Access from the Android library is like going back to the ADO.net ages, here's an example I found duckduckgo'ing the internet:

return database.query(DATABASE_TABLE,
  new String[] { KEY_ROWID, KEY_CATEGORY, KEY_SUMMARY, KEY_DESCRIPTION },
  null, null, null, null, null);

If you're thinking the above SCREAMING_CAPS look like they may be string constants, you would not be mistaken. Yes, the bare Android SQLite library drops you back to mapping an object manually. Hello, 2000.

So where did I go from here? What I've been using for a while is OrmLite, and while that certainly works, it has some massive memory leak problems, which, for a library that touts itself as "Lite" (I mean, it's in the name), is not very "lite" :).

Next steps were to look for a library that just bridged the database result set to object mapping gap, which is all I really wanted; ideally, something like Dapper for Java. Once again, numerous tools exist in this space but none supported Android out of the box.

DbUtils from the Apache foundation looks promising, but it once again needs JDBI drivers. Perhaps with SQLDroid I will achieve what I've always wanted!

Use Git to Manage Your Blog History

2015-10-06T12:21:04.000Z

Use Git to Manage Your Blog History!

One of the major problems of rolling your own weblog is properly managing the history of your posts.

The aim of this post is to elucidate how one can easily manage blog history, using only Git.

Why?

The best known methods for managing history of text documents have always been terrible. Yes, I'm speaking of Wordpress, but also commercial solutions like SharePoint, or the version tracking that has been built into Microsoft Word for the longest time.

Here's a list of cons that I always think of when using these tools:

```
Inconsistently track history
```
Sometimes can leave comments, sometimes can't
Usually diffing is either unavailable or is built using some proprietary/internal code that probably doesn't work well
Obfuscated via dense database models, XML formats, and/or binary formats
Difficult to use third party tools with them
Content management systems, which is what all blog engines are, need security to manage the blog. These security systems usually come riddled with bugs and security flaws.

Along comes lowly git, the little DCVS tool that could, which fills in the above gaps nicely. Combine this with a nice text format such as markdown, and you've got yourself a nice, versioned, document management system.

However, it does come with its own set of cons: 1. The git learning curve 2. Git doesn't natively take post metadata 3. Git is a version control system, and thus doesn't track file metadata either — so "true" file creation time, last modified time are not available 4. Wrapping git commands up in your favorite server-side language can sometimes be tricky 5. Versioning doesn't happen automatically, but rather on intentional commits

None of this is a show-stopper however. Yes, git is ridiculous to learn. Yes, you can't get "true" file creation time. But none of this certainly bothered me much.

How?

This is how I did it with nodejs:

Create a git repo (git init) where you want your posts to reside.
Use a nice sane format to store metadata about your posts. I'd personally go with at least a JSON-like format. Mine looks like below:
```
title: Use Git to Manage Your Blog History
author: vedvick
description:
---
```
The --- signals to the parser that the metadata section is complete.
Grab the posts from a configured or constant location. This is my highly sophisticated version:
```
glob(path.join(notesConfig.path, '*.md'), function (err, files) { ... });
```
Following a simple convention of prefixing filenames with the date the post is created, such as 20151006-use-git-to-manage-your-blog-history.md, the server can then easily and reproducibly sort the files by the created date.

Parsing the notes has a little sophistication to it. Here's the code used on my server in full:

var parseNote = function (file, callback) {
    parseNote.propMatch = /(^[a-zA-Z_]*)\:(.*)/;

    fs.readFile(file, 'utf8', function (err, data) {
        if (err) {
            callback(err);
            return;
        }

        var textLines = data.split('\n');

        var fileName = path.basename(file, '.md');
        var newNote = {
            created: null,
            pathYear: fileName.substring(0, 4),
            pathMonth: fileName.substring(4, 6),
            pathDay: fileName.substring(6, 8),
            pathTitle: fileName.substring(9)
        };

        var lineNumber = 0;
        for (var i = lineNumber; i < textLines.length; i++) {
            lineNumber = i;
            var line = textLines[i];

            if (line.trim() === '---') break;

            var matches = parseNote.propMatch.exec(line);
            if (!matches) continue;

            var propName = matches[1];
            var value = matches[2].trim();

            switch (propName) {
                case 'created_gmt':
                    newNote.created = new Date(value);
                    break;
                case 'title':
                    newNote.title = value;
                    break;
            }
        }

        newNote.text = textLines
                            .slice(lineNumber + 1)
                            // add back in the line returns
                            .join('\n');

        if (newNote.created !== null) {
            callback(null, newNote);
            return;
        }

        if (!notesConfig.gitPath) {
            newNote.created = new Date(newNote.pathYear, newNote.pathMonth, newNote.pathDay);
            callback(null, newNote);
            return;
        }

        exec('git -C "' + notesConfig.gitPath + '" log HEAD --format=%cD -- "' + file.replace(notesConfig.path + '/', '') + '" | tail -1',
            function (error, stdout, stderr) {
                if (error !== null) {
                    callback(error);
                    return;
                }

                newNote.created = new Date(stdout);
                callback(null, newNote);
            }
        );
    });
};

The neatest part here (and where git or some other version control system shines) is using it to determine the note's created date:

exec('git -C "' + notesConfig.gitPath + '" log HEAD --format=%cD -- "' + file.replace(notesConfig.path + '/', '') + '" | tail -1',
     function (error, stdout, stderr) {
         if (error !== null) {
             callback(error);
             return;
         }

         newNote.created = new Date(stdout);
         callback(null, newNote);
     }
 );

Note how this doesn't actually return the true "created" timestamp of the file, but it does, in my opinion, return a timestamp that is close enough.

When drafting a new post, create a new branch so the draft can be worked on in isolation without affecting work on other posts (for example, I posted an entirely different post while drafting this one). For this I also follow another convention: post/<post-name-here>. Of course, the convention is optional but I think at the very least it encourages consistency.
Finally, merge posts into master and push it to a web server. Then add a post-receive hook that checks out master to the location determined above: GIT_WORK_TREE=<note-location> git checkout -f

New Materialish Look for Audiocanoe

2015-10-13T12:20:17.000Z

New Materialish Look for audiocanoe

audiocanoe is seeing some updates coming up to match Google's new Material Design specs! Take a look below:

Sync your media to your phone with Audiocanoe

2015-12-24T19:51:57.000Z

Sync your media to your phone with Audiocanoe

Sometimes, Santa wants to listen to his music in his sleigh but his connection is spotty

What can Santa do? He can sync his music to his phone with the new version of audiocanoe that is in testing! Following the gif below, Santa can easily sync his favorite playlists and within minutes have them on his phone for playback:

To grab it, head over to the beta test site and opt-in to help test it out!

Happy holidays!

lazy-j: Lazy Java initialization library

2016-01-06T05:04:01.000Z

lazy-j: Lazy Java initialization library

Coming from the C# world, while working on audiocanoe I've often had the overwhelming desire to use something similar to the Lazy class that is in the Standard libs for .Net. Using it, you can easily initialize any object lazily without needing to implement your own double-check locked lazy initialization code.

So in a hasty moment, I wrote a library called lazy-j which supposedly guarantees your object will lazily be created the first time it is requested, using the supplied initialization function. It should also be thread-safe. It is also EXCEEDINGLY simple, here's the source:

package com.vedsoft.lazyj;

/**
 * Created by david on 11/28/15.
 */
public abstract class Lazy<T> {

    private T object;

    public boolean isInitialized() {
        return object != null;
    }

    public T getObject() {
        return isInitialized() ? object : getValueSynchronized();
    }

    private synchronized T getValueSynchronized() {
        if (!isInitialized())
            object = initialize();

        return object;
    }

    protected abstract T initialize();
}

There's some nice things here; it uses Java's built in synchronized methods to do a double-checked lock for object initialization. It doesn't have all the niceties of Microsoft's library (such as different degrees of thread-safety), but it gets the job done nicely while being simple enough to understand at a glance.

Usage is also fairly simple. To instantiate a new object do something like below:

class MyClass {
    .
    .
    .

    public static Lazy<MyCrazySingletonConfig> myCrazySingletonConfig = new Lazy<MyCrazySingletonConfig>() {
        @Override
        protected MyCrazySingletonConfig initialize() {
            final MyCrazySingletonConfig newConfig = .....

            return newConfig;
        }
    };    
}

class SomeOtherClassThatNeedsConfig {

    public void doingThingsWithConfig() {
        final String property = MyClass.myCrazySingletonConfig.getObject().getMyCrazyProperty();
    }
}

You can view the source here!

What is Software Engineering and are we Software Engineers?

2016-05-19T05:31:58.000Z

What is Software Engineering and are we Software Engineers?

In our day jobs, we often call ourselves many things (or our HR departments call us these terms for us):

Software Developer
Programmer
Software Designer
Software Engineer
Technologist (what does this even mean?)

I think most of us prefer the term "Software Engineer" at the end of the day; it tends to properly transmit the problem-solving needs, due diligence, and rigor required in our job, even if we don't apply those three traits all the time. We even may work with people ensuring the validity (and thus quality) of our software, who hold the title of "Software Quality Engineer".

But what really defines a Software Engineer? It's not enough to just have a title that gives a good feeling of the difficulties our job entails - is it? Well this question is answered easily enough - a Software Engineer is someone who practices Software Engineering!

But then the next practical question becomes... what is Software Engineering? Wikipedia gives Software Engineering five possible definitions, which I'll repeat here for convenience:

"research, design, develop, and test operating systems-level software, compilers, and network distribution software for medical, industrial, military, communications, aerospace, business, scientific, and general computing applications."

"the systematic application of scientific and technological knowledge, methods, and experience to the design, implementation, testing, and documentation of software";

"the application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software";

"an engineering discipline that is concerned with all aspects of software production";

"the establishment and use of sound engineering principles in order to economically obtain software that is reliable and works efficiently on real machines."

Ok, so many of these definitions look somewhat flimsy on the face of it; perhaps for proper definition, one should look at what gave birth to other engineering disciplines.

The Birth of an Engineering Discipline

Mary Shaw from Carnegie Mellon University in a keynote address at the International Conference on Software Engineering, determined that an engineering discipline emerges following these rough steps:

A diagram detailing the process a craft practice goes through to become an engineering discipline

People begin using a new discovery or tool to solve some problems in simpler, newer, faster ways; this is the emergence of a craft practice around this discovery - say the "The emerging field of " - or The emerging field of Computer Science in the late 1950s through the 1980s.
Some of these people start businesses with their new, disruptive products, others are hired to disrupt existing businesses
The businesses begin running into problems with the new products, eventually practitioners of the craft in the field cannot solve problems of ever increasing complexity alone, spurring the need for research into how solve these problems
Scientists develop new practices and methodologies, make new discoveries in the field to solve problems; in order to properly disseminate these findings, the scientists use all tools available: documentation, training, etc.
The findings of these discoveries eventually coalesce into a discipline; finally we have engineering!

Software development is far along the path of becoming an engineering practice; people use the computer sciences to solve common problems in business, government, and medical fields. As problems are found with current patterns and practices, subsequent solutions are found, and disbursed through many avenues (a common one in our field is Stack Overflow!).

Some tools and processes seem to introduce sea-changes in producing reliable code. The SOLID approach to object-oriented software design was one. From this, a whole literature has stemmed to produce consistently SOLID software designs. Peer review and test-driven development also seem like step-wise improvements in producing reliable software (by stressing as many variations of state that take place in a finite state machine as possible at time of development, a developer takes the step of not only ensuring correct operation of the code at the time of development, but also correct forward operation of the code in the future).

However, we aren't quite at the point where the science and tooling and practice sides of the equation have caught up to produce highly reliable code and solve novel problems at a high frequency.

If Building Software is not yet an Engineering Practice, are we Engineers?

Now comes the chicken and egg question: does an engineering practice make an engineer, or does an engineer make an engineering practice?

Instead of using the above process that Mary Shaw went through to define an engineering practice, let's look at what defines an engineer. From there we can maybe answer the question of what an engineer is without answering the question of what an engineering practice is.

Let's think of the situation of an electrical engineer and a certified electrician: both are capable of designing operating electrical circuits. Both are knowledgeable in the real-world limits and dangers of electrical equipment and components. An electrician can likely solder components onto a board just as quickly and deftly as an electrical engineer. In other words, they're both capable of understanding and applying circuit theory.

Where do they differ? What makes an electrical engineer's degree and certification harder to achieve? What do electrical engineers bring to the table that electricians do not? Perhaps the engineer solves novel electrical problems, but I think that an electrician is also capable of that when working within his own knowledge and what he has learned beyond that. Perhaps the engineer is tasked with staying at the forefront of his field, but a good electrician should also stay current with the field (and may be required to as well by government).

It seems more correct to say that electrical engineers (are supposed to) have the ability to contribute back to the fields of electrical engineering when a novel problem requires a novel solution outside of the bounds of the existing body of knowledge of the electrical engineering field. So maybe it is sufficient to say that an Engineer has enough mastery of the field they work in that they can contribute back to their field with novel solutions from outside of the discipline as it exists in that moment.

So are software engineers, you know, engineers? In most engineering disciplines, proper testing and certification is required by state and national boards in order to properly claim that one is an engineer. This type of certification does not exist yet. IEEE offered a Certified Software Development Professional program at one time, but that was discontinued in 2014. Instead, they now offer certifications in multiple areas of software development, with the reasoning seeming to be that software development covers too broad of a spectrum of software creation at the moment to be grouped into one certification.

So at present, it doesn't seem that there are any widely recognized certifications that provide a definitive "software engineer" title. However, that doesn't mean that there are not many of us today who are in effect practicing the same disciplines as other engineers; it just may be that there is not yet enough agreed upon material for there to be a known, written determination of what makes the software engineering discipline.

So what?

I do predict that one day - perhaps 1500 years from now, but hopefully not that long - the title of Software Engineer will be a professional distinction that will require full testing and certification. At the end of the day, does any of this matter? If the rest of the industry is following the title of "Software Engineer", then there doesn't seem to be any good reason to be apprehensive to the usage of the title of Software Engineer. However, I think after taking all of the above into account, we should feel encouraged and motivated to continue growing our practice, and contributing as much as we can to the development of software engineering as a discipline!

Concurrency vs. Parallelism: A breakfast example

2017-12-03T17:45:49.000Z

Concurrency vs. Parallelism: A breakfast example

One of the harder problems in Computer Science is concurrency. This summer at my employer, I gave a presentation on asynchrony, which I consider nearly the same thing as concurrency. One of the things that I felt was lacking was my explanation of concurrency vs. parallelism. I ended up just giving a textbook explanation:

Parallel processing is taking advantage of a lot of processors (local or remote) to run calculations on large volumes of data
Asynchronous execution is freeing up the processor to do other things while a lengthy operation is occurring

This morning, however, I was making myself breakfast, and I thought up a useful analogy.

A breakfast example

My breakfast this morning consisted of a coffee and two slices of toast with peanut butter.

A perfect example of concurrency was how I made the breakfast: I first started the toast, then put the coffee cup in the Keurig and pushed the brew button on the Keurig. This is a concurrent operation - one job (toasting the bread) was started, and after that began, I (the processor) was freed up to start another job, the "brew coffee" operation.

We can take this analogy further: the toaster can actually process two pieces of bread at once, which is a parallel operation. From here, we can easily see that parallelism is a subset of concurrency: technically, the toaster is technically performing two operations concurrently, what makes it a parallel operation is the fact that it's the same process occurring twice, started at the same time within the same machine.

Should we write this as C#?

public static class Program {
  public static void Main() {
    MakeBreakfast().Wait();
  }

  public static async Task MakeBreakfast() {
    // Start toast - this operation takes the longest to complete, so let's get
    // it started as soon as possible
    var toaster = new StandardToaster(new ElectricitySupplier());
    var toastingTask = toaster.Toast(new WheatBread(), new WheatBread());

    // Now start the Keurig, a relatively short operation
    var brewer = new Keurig(new Water());
    var brewingTask = brewer.Brew(new DarkCoffee());

    // Don't return control to the human until operations complete
    await Task.WhenAll(toastingTask, brewingTask);
  }

  public interface Toaster {
    public Task<IEnumerable<Toast>> Toast(Bread bread, Bread bread);
  }

  public interface Brewer {
    public Task<Coffee> Brew(GroundCoffee groundCoffee);
  }
}

Concurrency and Parallelism in Real Life

The thing about concurrency and parallelism is that you can do this all the time; for example, humans are terrible at multi-tasking (parallel processing), but are great at starting multiple jobs, and then taking action when they finish (concurrent processing).

I encourage everyone to always think of how the things they do in real life apply to different concepts in software development. Since software development is all about automating real life processes, these analogies actually occur much more frequently than one would expect!

Things I've Built Building an Android Music Player

2018-04-08T17:02:45.000Z

Things I've Built While Building an Android Music Player

Five and a half years ago, I began building an Android application to stream music from my home server, which runs J River media center. Looking back, the journey has been as or more rewarding than the destination, as I only have about 20 active users on a given day beyond myself, but the software I've built along the way has been extremely fun to build. On the other hand, it's often been an act of frustration to build an application in Android's language of choice, as many of the tools I expected to have even back in 2012 were missing from the Java ecosystem. As a result, I built some of these tools myself.

Those tools were Lazy-J, a simple Lazy instantiation library, Artful, a library that serializes SQLite queries and results from and to Java classes, and Handoff, a promise library for easy asynchronous programming. While each of these libraries could probably have had many posts devoted to each of them, I find writing painful, so I'll devote this one blog-post to them all, and hopefully do them some of the justice they deserve.

Lazy-J

One of the things I missed when I was working in Java was the lack of lazy instantiation in the standard library. While there's all sorts of recommendations on how to do lazy instantiation, the approaches usually only apply to static methods, and rely on intimate knowledge of the runtime and Java spec to properly expect lazy operation. I needed a way to do a private final Lazy<MyObject> lazyObject = new Lazy<MyObject>(), because I often needed to use a shared resource in my Android view objects without knowing when they'd be created.

I've seen IOC frameworks such as Dagger do this, but my application was never complicated enough to warrant using an IOC framework. I also confess to not being a huge fan of Java IOC frameworks due to their dependence on attributes (although it's understandable given the language's limitations).

Usage of Lazy-J is pretty straight-forward - a simple usage, just new-ing up an object, looks like this:


class MyClass {
  private readonly Lazy<Object> lazyObject = new Lazy<Object>(Object::new);
}

I've abused Lazy-J excessively, for example, I don't want to have to run findView all the time to get a view, so I have a class titled LazyViewFinder, which will hold on to the reference to the view the first time you use it. This class lets me hold a reference to the view in my class, so I can reference my views like this:

public class Activity {
  private LazyViewFinder<TextView> lblConnectionStatus = new LazyViewFinder<>(this, R.id.lblConnectionStatus);

  protected void handleConnectionStatusChange(int status) {
    .
    .
    .

    final TextView lblConnectionStatusView = lblConnectionStatus.findView();
        switch (status) {
        case BuildingSessionConnectionStatus.GettingLibrary:
            lblConnectionStatusView.setText(R.string.lbl_getting_library_details);
            return;
    }
    .
    .
    .
  }
}

You can find lazy-j at https://github.com/danrien/lazy-j.

Artful

Artful is a library which also began as a source of frustration: at the time (and even today?) there are not many easy, transferable ways to easily map the results of a SQL query on the built-in SQLite database to a Java object.

In C#, using the excellent Dapper library, one can just do this:

using (var connection = new SqlConnection())
{
  return await conn.QueryAsync<MyObject>("select * from my_object");
}

Perfectly bridging the gap between SQL Queries and a strongly-typed languague, while still allowing each language to flex its respective strengths (small note: I think future interop efforts between languages should focus on these types of bridges).

Due to type erasure, we can't do quite the same thing in Java, but with Artful, I managed to get pretty close:


public Collection<Library> getLibraries(Context context) {
  RepositoryAccessHelper repositoryAccessHelper = new RepositoryAccessHelper(context);
  try {
      return
          repositoryAccessHelper
              .mapSql("SELECT * FROM library")
              .fetch(Library.class);
  }
}

Artful is new'd up inside of RepositoryAccessHelper, which does this:

public Artful mapSql(String sqlQuery) {
    return new Artful(sqliteDb.getObject(), sqlQuery);
}

Since Artful caches the SQL queries and the reflection, it becomes pretty performant after the first round of serialization on a given class. It is by no means feature-complete, for example it can't serialize directly to primitive types - repositoryAccessHelper.mapSql("SELECT COUNT(*) FROM library").fetchFirst(Long.class) would likely give you nothing - but it has served me remarkably well, without memory leaks as well.

You can find Artful at https://github.com/namehillsoftware/artful.

Handoff

Asynchronous programming in Java is really painful. Java has Future, which purports to be the way to perform asynchronous behavior, but it merely introduces a spin-lock to achieve receiving a value synchronously on your calling thread. While this may be fine behavior for a server application (although many a NodeJS and nginx server may disagree with you on the principle of thread starvation), for a desktop application, knowingly introducing blocking behavior into your application is border-line offensive.

Android attempted to make this better with AsyncTask, but I found it to be nearly as painful to work with as Future:

It's difficult to easily chain one asynchronous action to another without developing verbose APIs
It has messy internal state that leaks into your consumption of the library with unchecked exceptions
Results post back to the UI thread that it was called on, which is often all that is wanted in simple applications, but the second you have to perform additional asynchronous work, starts to cause troubles

Handoff is the last library I've developed for my little music player, and the one of which I am proudest. Handoff aims to be a Promises A+ like promise library for Java. While Java has CompletableFuture, I find its API surface layer to be rather large. In this instance, I also found C#'s Task library to be very verbose - they had to introduce an entirely new language primitive just to make it easier to work with (async/await)! I even speculate that the Task library was explicitly written to set the stage for async/await ;).

I really like the ergonomics of Javascript's Promise class, and thought it would be fun to see if I could make something like that for Java. It has both been fun to develop and tremendously beneficial! I wish it was easy to show a side-by-side comparison of my app's responsiveness before and after using Handoff, but the difference has been night and day for me - ever since switching to a promise-like async model, I rarely get UI hangs or unresposive warnings from the OS, and unexpected IllegalStateException hangs have gone completely away.

Handoff in the simple case is used like this:

new Promise<>(messenger -> {
    final IPositionedFileQueueProvider queueProvider = positionedFileQueueProviders.get(nowPlaying.isRepeating);
    try {
        final PreparedPlayableFileQueue preparedPlaybackQueue = preparedPlaybackQueueResourceManagement.initializePreparedPlaybackQueue(queueProvider.provideQueue(playlist, playlistPosition));
        startPlayback(preparedPlaybackQueue, filePosition)
            .firstElement() // Easily move from one asynchronous library (RxJava) to Handoff
            .subscribe(
        playbackFile -> messenger.sendResolution(playbackFile.asPositionedFile()), // Resolve
        messenger::sendRejection); // Reject
    } catch (Exception e) {
        messenger.sendRejection(e);
    }
});

The returned promise can then be chained as you'd expect:

playlist.promiseFirstFile()
  .then(f -> { // Perform another action immediately with the result - this continues on the same thread the result was returned on
    // perform action
    return f; // return a new type if wanted, return null to represent Void
  })
  .eventually(f -> { // Handoff the result to a method that is expected to produce a new promise
    return new Promise<>(m -> {

    });
  })
  .excuse(e -> { // Do something with an error, errors fall through from the top, like with try/catch
    return e;
  })

Handoff can be found here - https://github.com/danrien/handoff.

And the application that motivated me to build all of these little libraries is Music Canoe, which can be found here - https://github.com/danrien/projectBlue.

A Conceptual Model of Async/Await

2019-03-24T15:30:58.000Z

A Conceptual Model of Async/Await

Microsoft released the async/await programming model to the world in 2012. While many of us diligent C# developers have been advocating the use of async/await since then, I have noticed many programmers still struggle with finding the benefits of async/await worth the cost of understanding. There's a few behaviors I notice when looking through code:

Developers will often go for synchronous code over asynchronous
Continued use of Task.Result to force a task into performing synchronously

These behaviors indicate (to me) that developers have a hard time seeing the benefit of asynchronous code over synchronous. And to be fair, in their day-to-day development activities, it may seem like async/await just adds another layer of cognitive overhead to an already difficult job. Throughout this post, I will try to give a simple model with which to conceptualize async/await and show some of the fun things you can do with async/await.

Most of this text is also applicable to Javascript Promises, and their async/await implementation. This is because C# Tasks and Javascript Promises are both implementations of the same construct, better covered by Wikipedia than myself: https://en.wikipedia.org/wiki/Futures_and_promises.

The Simple Model

This is all that async/await does:

An await signals that you desire for your current line of code to pause execution until the task you are waiting for completes execution. Once the task completes, the code after your current line will continue execution. You can only await an object that has a GetAwaiter() method which returns an implementation of INotifyCompletion. In the wild, this is usually a Task class.
An async tells the compiler that you want to use the await keyword in a function. The function must return a type Task<...>.

Uses

Now that we have a simple conceptual model for async/await, we can have a lot of fun with async/await while continuing to write code that is easy to reason with.

Imperative Code Style

Below is a simple example to illustrate the difference between using a Task with continuations and using a Task with await:

public Task Main()
{
  GetData()
    .ContinueWith(myData =>
    {
      var myProcessor = new Processor();
      return myProcessor.Process(myData.Result);
    }, TaskCompletionOptions.OnlyOnRanToCompletion)
    .Unwrap()
    .Wait();
}

The above callback style model can become this:

public async Task Main()
{
  var myData = await GetData();

  var myProcessor = new Processor();
  await myProcessor.Process(myData);
}

This contrived example obviously doesn't show much, but the code does arguably become cleaner. Async/await also opens us up to using other programming constructs, such as loops, with our asynchronous code. So taking the above example, let's say the data is an IEnumerable:

public async Task Main()
{
  var myData = await GetData();

  var myProcessor = new Processor();

  foreach (var data in myData)
  {
    await myProcessor.Process(data);
  }
}

I'm not even going to bother to try to write this with a Task chain! It's important to note that while this code does not block while waiting for the data to process, the code still does execute in-order. Async/await enables us to write non-blocking code with our typical C# programming style, which is really neat. However, we can do some even more interesting things with Tasks.

Interleaving

Interleaving is one of my favorite uses of async/await. Rather than immediately pausing execution on a long-running task, we can start execution of the task, hold onto the task itself, and then start execution of other tasks in the meanwhile. When we're actually ready for the result of the first task, we can then await it. For example:

public async Task Main()
{
  var myDataTask = GetData(); // Hold onto a reference of the Task, rather than the result of the Task

  // Execution can still be paused in the method on the Tasks below, and the myDataTask
  // will continue execution in its own synchronization context (usually a Thread)
  await Console.WriteLineAsync("Please input some additional data while the other data loads!");
  var additionalData = await Console.ReadLineAsync();

  var myProcessor = new Processor();

  // Finally pause for `myDataTask` to complete execution
  await myProcessor.Process(await myDataTask, additionalData);
}

This allows gathering data from your data source while the user is keying in other data, potentially masking the time it took to retrieve the data from the data source.

Racing

Tasks also have the combinatorial helpers Task.WhenAll(Task...) and Task.WhenAny(Task...) (or Promise.all(Promise...) and Promise.race(Promise...) for those Javascript folks following along). While the applications of Task.WhenAll may seem obvious (and I will cover them soon), it is a little more difficult to find a use for Task.WhenAny. Often times, I'll use Task.WhenAny when I want to execute multiple tasks and change the control flow of my program as a result of which task completed first - timing out execution is a clear use case for this pattern.

Let's say we're waiting for our data to come in on a message bus:

public async Task<int> Main()
{
  var myDataTask = GetDataOffOfMessageBus();

  var raceResult = await Task.WhenAny(myDataTask, Task.Delay(TimeSpan.FromMinutes(30)));

  if (myDataTask != raceResult) // Task.WhenAny returns a `Task<Task>`, whose result is the winning task
  {
    await Console.WriteLineAsync("What's taking that message so long?");
    return -1; // Unceremoniously stop the program
  }

  var myProcessor = new Processor();
  await myProcessor.Process(await myDataTask); // You can also await the same Task multiple times, the result is held onto by the task once it completes, so it will always be the same **reference** or **value**

  return 0;
}

Aggregation

Once you start interleaving and racing your code, you will start having the desire to just not wait at all for anything until it's absolutely needed. Aggregation of your tasks using Task.WhenAll(Task...) can help you with this.

Let's take the above example where we iterated over an IEnumerable of data. Let's instead use the combined power of LINQ and Tasks to process all of that data all at once:

public async Task Main()
{
  var myData = await GetData();

  var myProcessor = new Processor();

  await Task.WhenAll(myData.Select(async data =>
  {
    await myProcessor.Process(data)); // You could also just return the Task returned by `Process`, which might give you some speed benefits
  });
}

A Cautionary Note

It's important to note that except for the first two examples, all the above examples introduce concurrency into your code. Along with concurrency come all the concerns that plague concurrent models: deadlocks, unsynchronized state, etc. That being said, it's still completely acceptable (and possible) to write non-concurrent code with async/await, such as in the first two examples, and still realize benefits. That's because every operating system comes with a maximum number of supported native threads [0][1] (which many runtimes use) and an await call frees up that thread to either be used by something else, or to be collected by the garbage collector. This is why async/await helps your application more efficiently use its hosts resources - whether it be for parallel processing or just conservative use of threads. I hope you come to enjoy the benefits of having the more responsive and conscientious applications that async/await brings you as much as I have.

[0] Increasing number of threads per process (Linux) (https://dustycodes.wordpress.com/2012/02/09/increasing-number-of-threads-per-process/)

[1] Does Windows have a limit of 2000 threads per process? https://devblogs.microsoft.com/oldnewthing/20050729-14/?p=34773)

The Satisfaction of UI Development

2019-09-21T04:47:54.000Z

The Satisfaction of UI Development

There's something oddly satisfying about UI Development. These days I spend most of my time doing back-end, server-side work, and that's highly satisfying as well... but there's something about being able to see and play with the results yourself when a change is made.

Anyways, that's of course going to lead to a screenshot of my latest update to project blue, which introduced a fancy, transparent, right-handed sliding drawer for the Now Playing list:

May 2021 Log

2021-05-01T00:00:00.000Z

May 20th, 2021

These are notes I took from the 2021 Open-Source North conference, which takes place annually in Minneapolis, Minnesota

Deep Learning for Natural Language Processing

Natural Language Understanding (NLU) is the focus of this talk

Natural Language Generation

Mapping from computer representation space to language space
Opposite direction of NLU

Deep Learning

Subfield of machine learning
Algorithms inspired by the structure and function of the brain called artificial neural networks
Advantage over machine learning is to extract features automatically

Text is Messy

Punctuation, typos, unknown words, etc.

Preprocessing Techniques

Turn the text into meaningful format for analysis (tokenization)
Clean the data

Remove: upper case letters, punctuation, numbers, stop words
Stemming
Parts of speech tagging
Correct misspelled words
Chunking (named entity recognition, compound term extraction)

Preprocessing: stemming

Stemming and Lemmatization = cut word down to base form

Stemming: uses rough heuristics to reduce words to base
Lemmatization: uses vocabulary and morphological analysis
Makes the meaning of run, runs, running, ran all the same

Bag of words

Way of representing text data when modeling text with machine learning or deep learning algorithms

Word embeddings

Type of word representation that allows words with similar meaning to have a similar representation

They are a distributed representation of text
Word embedding methods learn a real-valued vector representation for a predefined fixed sized vocabulary from a corpus of text

Word2Vec

Problem: count vectors far too large for many documents
- Solution: Word2Vec reduces number of dimensions (configurable, e.g. 300)
Problem: bag of words neglects word order
SkipGrams: SkipGrams is a neural network architecture that uses a word to predict the words in the surrounding context, defined by the window size
Continuous Bag of Words: CBOW uses the surrounding context
What happens? Learns words likely to appear near each word
Vector scan combined to create features for documents
Use Document Vectors for ML/DL on documents (classification, etc.)

Feature Selection

Manual process in traditional machine learning techniques, which happens automatically in deep learning

Embeddings + CNN

Using word embeddings for representing words and convolution neural network for classification task. Architecture has 3 pieces:

Word embedding model: generate word vectors
Convolutional model: extracts salient features from documents
Full-connected model: interpretation of extracted features in terms of a predictive model

Recurrent Neural Networks

Networks with loops
Allows information to persist
Enables connecting previous information to present task
Context preserved

Vanishing Gradients with RNN's

In the simplest form RNN's don't work as well as wanted
Learning rate drops with back propagation
Long-Short-Term Memory units help combat the vanishing gradient problem by introducing an "error carousel".
- Allows learning sequences, keeping track of the order without a vanishing gradient

Major challenges with DL for NLP

Data size: RNN/LSTM doesn't generalize well on small datasets
Relevant Corpus: required to create domain specific word embedding
Deeper Networks: empirically deeper networks have better accuracy
Training Time: RNN's take a long time to learn

https://github.com/hardlyhuman

Robot Rock - AI and Music Composition

Previous Examples of Music Generation:
- Mozart?! - developed game for auto-generating music
- ILIAC 1
- Neural Networks

Machine Learning used for Music Generation

Standard feed forward networks aren't a good fit for predicting sequential events (e.g. music, text)
- Limitation: fixed number of inputs/outputs

Recurrent Neural Networks (RNN)

Better for text/music
LSTM is key to improving results

Music Encoding Options

MIDI
Waveform

Programs that Do Music Generation

Amper
AIVA
- Generational soundtracks for video games?!
LANDR - AI based mastering of music
Magenta (Google)
OpenAI: MuseNet (built off of MuseTree), JukeBox
PopGun
Live Performance toolsTidal Cycles, Orca

Artists That Use AI

Taryn Southern - I Am AI (2018)
Yacht - Chain Tripping (2019)
- Transcribed entire backlog to MIDI to train Magenta
- Treated ML as a collaborator
Holly Herndon - Proto (2019)
- Created "Spawn", which performed music
- She earned her PhD based on this album

Lyrics Generation

GPT-2 has a model to generate lyrics

Empowering Streams through KSQL

Querying Kafka streams through KSQL
Custom Data Integration is hard: ephemeral isn't useful, stateful is hard
Kafka: A-B integration allows loose coupling, with Kafka as the middle layer
Kafka can handle load with a very predictive, linearly scaling, model
Kafka partitions data with "Topics"

Kafka Data Transformation

Single Message Transforms (SMT)
- Transformations configured via JSON
KStreams: advanced message transforms in Java
KStream - unending list of messages arriving
KTable - a projection of the most recent value in a KStream

ksqlDB

Uses a SQL interface to work against KTables/KStreams

Emit changes keyword continuously runs query
Has basic querying capabilities, and other functions, that work against Kafka streams

Lessons on Chaos Engineering

Chaos engineering is an experiment, building an experiment around steady-state hypothesis.

Not all signs are useful.
"The future seems implausible, the past incredible"
Weak signals are the signals we get before something goes wrong, and are an important insight into something before it goes wrong
Search for how close we are to failure
Past signals may not be future signals, future signals may come from areas that were not signalling before

Insights that Come From Weak Signals

On-Call shifts should end on Fridays!
- Engineers are tired, and
- On-call shifts ended on Fridays and begin for the next person Friday
A designated "ops-support" person
"I don't know anything about this, we'll need to talk to Emma.": signalling the system is approaching a boundary - what happens if Emma decides to pursue other opportunities?
Value proposition of chaos engineering is the insights you gain
Rare that a single signal is strong enough
Having a multi-functional product team is the best way to make products

Technical Excellence through Mob Programming

Retrospectives: tie together learning time
1 year of no bugs! Organization chose to scale mob programming.

How to Mob Program

The Mob Programming RPG

https://github.com/willemlarsen/mobprogrammingrpg

Driver: drive the PC
Navigator: gives the directions on what to program
Mobber: yield to less privileged voice, contributes ideas
Researcher: break off on tangents to look into different ideas
Sponsor: speak-up for others
Navigator of the Navigator: navigates the navigator!
Automationist: sees a developer doing the same thing over and over again, might be able to automate those things
The Nose: calls out code smells
Traffic Cop: keeps everyone in line

Other Mob Role Taxonomies: other mob role taxonomies exist

Goals

Treat everyone with kindness, consideration, and respect
No one between code and production
Clean Code - code expressed cleanly within the domain
Zero Bugs!
Deliver Working Software to Production Consistently
Anyone can take a vacation (zero silos)
Effective interdepartmental ownership
Continuously develop lofty goals and practices
Experiment Frequently with small changes

Benefits

High Bandwidth Learning
Quality and Technical Debt
Group Conscientiousness
Flow is easier in a mob vs pairing
No more bugs!

Law of Personal Mobility

If you are not contributing or learning, go to a different mob

There and Back Again: Our Rust Adoption Journey

Async implies IO
& means the type that is passed into a method is immutable
- async fn verify_signature(token: &Jwt)

State Machines - enabled by enum types having fields

enum User {
  Pending {
    email: Email
  },
  Active {
    email: Email,
    confirmation_timestamp: DateTime<Utc>
  }
}

Future looking - new states can be added, and compiler will tell you when a state isn't covered
Predictable performance - rust is fast, but more importantly, its performance isn't affected by things such as garbage collectors
The Rust book is a great place to start
Rustlings

May 2022 Log

2022-05-01T00:00:00.000Z

May 28th, 2022

It's always easier to expand scope than to constrain or reduce it
Prescribed problem-solving processes that don't include a post-mortem or lessons learned don't create sustainable change (at least we weren't asking how we could prevent it in the future)

May 22nd, 2022

Should I split "notes" into two sections: "thoughts" and "logs"?

May 19th, 2022

Update personal website to display log (a la twitter?)
Most static analyzers should be shut off on unit tests, except for some basic formatting linters (whitespace)

Architecture Notes

http://arc42.org
http://doctoolchain.org
arc42 by Example
- Subset of arc42 that author always uses:
  - Introduction
  - Context
  - Solution Strategy
  - Building Block View
  - Decisions
  - Concepts
Architecture Diagrams
- System: entire system
- Subsystem: submodules of the system

Switch Notes

2022-05-28T00:00:00.000Z

Notes from the book Switch: How to Change Things When Change is Hard by the Heath Brothers

Self-control is an exhaustible resource
What looks like resistance is often lack of clarity
Big problems are often solved with a sequence of small solutions
Pursuing bright spots - "what's working, and how can we do more of it?"
BHAG - Big Hairy Audacious Goal
Big picture goals (be healthier!) make it easier to rationalize failure
Change in people happens in this order: see-feel-change
We define terms in ways that satisfy us
If you want to inspire something to change, make it clear that progress has already been made
Inspire people to be more determined, more motivated, more ready to act
When people make decisions they rely on two models: the consequences model and the identity model
Any change effort that violates someone's identity is likely doomed to failure
Identities grow from small beginnings
A growth (instead of fixed) mindset is key to achieving new things
Project mood chart: U-shaped curve with a peak of "hope" at the beginning, second peak of "confidence" at the end, and a negative emotional valley of "insight" in the middle
What looks like a person problem is often a situation problem
People are more likely to change if you make it easier for them to change
Sterile cockpit - give coders time during the week where they aren't interrupted
Shape the environment to encourage change
Habits are "behavioral autopilot"
Habits change when the environment changes
Pre-load decisions to overcome environmental habits (action triggers)
Action triggers need to be specific and visible enough to interrupt normal stream of consciousness
Behavior is contagious
When the herd embraces the correct behavior, publicize it
Free spaces allow reformers to come together while feeling safe from the conservatives

June 2022 Log

2022-06-01T00:00:00.000Z

June 18th, 2022

A very unexpected lunch of parades and airplanes while getting a meal from one of my favorite places in St. Louis Park, MN!

June 16th, 2022

The only business model that can apply to software that receives continuous updates is a subscription or subscription-like model.

June 10th, 2022

Is all German flooring 0-based?

June 8th, 2022

Many websites use location based localization, so if you visit a site from another country, even if you frequently visited it from your home country, it will assume you're a speaker of the destination country's language.

June 4th, 2022

Writing should be a (simple?) joy in order to encourage its use (something Twitter gets right by limiting the number of allowed characters)

June 3rd, 2022

project blue file details control buttons

Clicking on a file from a list should show file details
When viewing from "Now Playing"?
- Show "pause" when a file is playing
- Show "play" when a file is paused or not playing (and it is in now playing file details)
When viewing from elsewhere:
- Show "pause" when a file is playing
- Show "play with playlist" button when not playing?

Large societies have trouble with minority groups due to herd mentality writ large?

Language Features and Inescapable Implementation Details

2022-06-20T15:25:29.000Z

Language Features and Inescapable Implementation Details

My main gripe with async/await in .Net, which makes the use of Task objects to look more similar to procedural code, is the recommendation that when using await in a library package, Task.ConfigureAwait(false) should be used in order to ensure the task doesn't continue on the called context. This is to prevent deadlocks on single-threaded synchronization contexts such as UI synchronization contexts.

An alternative approach to ConfigureAwait(...) could instead be syntax that improves the usability of synchronization context switching. Something like this:

 // New keyword "on", that then expects a synchronization context afterwards
var result = await longRunningProcess() on UISynchronizationContext;

This would have the benefit of giving the application developer improved control in the behavior of their app, while reducing the burden on library developers to make their async/await code "safe" for consumption.

I think this is a more general problem for any programming language introducing a concept meant to paper over the "hard stuff": invariably, the "hard stuff" creeps up, unless the sugary feature is very well thought out and future looking. And in the end, it seems the solution to the inescapable implementation details of syntactic sugar is introducing more syntactic sugar. I think there's a lesson here: for a new language feature to have successful adoption, it needs to minimize harm and maximize helpfulness...

June 2022 Log

2022-06-23T00:17:00.000Z

June 30th, 2022

If you think today's Wordle was hard, try using WPF transforms.

June 23rd, 2022

I have a sneaking suspicion that Intuit is actively trying to kill Mint with the ever-increasing number of authentication steps.

July 2022 Log

2022-07-07T00:17:00.000Z

July 7th, 2022

Simple things Tesla could do with their overpowered CPUs and GPUs to improve the driving experience:

Range estimation based on weather, simply requires data (of which they have plenty) and regression models, using temperature, windspeed, and altitude changes as an input. To make it fancy, they could adjust it based on predicted temperature along a route, but while technically feasible, this might be a major pain. To make it even fancier, they could add component lifetime as an input. All of this is hard with traditional rule-based systems, but should be natural for machine learning. Supposedly, Tesla has a supercomputer creating advanced ML models that could easily create this kind of model.
Simulate summer weather braking during winter weather
Predicting component lifetime, detecting car problems ahead of time

August 2022 Log

2022-08-17T15:59:00.000Z

August 20th, 2022

MUT = module under test. Fun to write, read, and say, and generic enough to describe any level of test, while also specific enough to connotate this is local code under test. Also, a "mutt" is a canine breed of many different types, which I think fits well with "module under test" as well.

August 18th, 2022

A defect is ordering a Big Mac with Cheese and receiving a Big Mac without any cheese. A critique is saying "boy this sandwich could really be improved with some barbecue sauce." This may seem obvious, but the latter is not a defect, it's a new requirement.

August 17th, 2022

Presentations follow a general format of 1) give presentation, and 2) question and answer. If the same presentation is presented multiple times to different audiences, then the Q&A tends to differ, out of which a "Frequently Asked Questions" list can be compiled. I wonder if there's a way to formalize this approach with existing presentation software (Powerpoint would be nice, but it would be easier to build something off of OS Markdown based presentation tools).

September 2022 Log

2022-10-09T15:53:14.000Z

September 16th, 2022

TODO: Register the project blue File Details activity for mime-type application/x-mediajukebox-mpl.

September 14th, 2022

One day, the ultra wealthy, taking the baton from generations of the ultra wealthy who preceeded them, will attach giant rockets to the earth's moon and fly away, living their lives in hermetically sealed environments and enjoying the Earth as they thought it should be in their VR metaverse. In true keeping with their predecessors, they will leave cleaning up the mess created by their action to the less fortunate left behind (losing the moon would destroy Earth's ecology in many ways). I have a hard time deciding whether I am making a joke or not 🤔.

October 2022 Log

2022-10-09T15:58:21.000Z

October 13th, 2022

Software is too easy to change, which makes it easier to make breaking changes. This is another reason to add unit tests - to make code that is performing its function hard to change in the wrong ways.

October 9th, 2022

project blue File Properties Editor

The file properties editor should popup a dialog when a certain property is touched, and the user should then have to initiate editing by clicking a button - it should be difficult to change such data through a User Interface.

Integration Tests

An issue with higher level integration tests is that the implementation of a method becomes intertwined with its usage.

November 2022 Log

2022-11-03T23:26:53.000Z

November 13th, 2022

The power of the Fediverse is that there can be a mastodon instance that has all verified, paid accounts, and there can be instances that are all anonymous accounts. The biggest risks I find with the Fediverse concept is that governments can more easily pressure, infiltrate, etc. small instances, not that this doesn't happen with Twitter as well.

Anyways, my Fediverse account is on Fosstodon now.

November 3rd, 2022

Microsoft has a command line upgrade assistant to help with porting .Net framework to .Net core now - https://dotnet.microsoft.com/en-us/platform/upgrade-assistant. I wish this had been available when I ported 60+ .Net framework projects to .Net core 2.2!

December 2022 Log

2022-12-12T21:02:41.000Z

December 29th, 2022

It took me a long time to realize the Rx libraries [0] are most useful for UI state and not useful for data access (and perhaps even harmful). For data access, traditional pulling/enumerating methods should be used, but for UI state, Rx observables are downright magical.

[0] "Rx Libraries" refers to the libraries published on https://reactivex.io/

December 12th, 2022

One area where software testers can add value is in providing an external voice questioning software requirements. I think this value addition is best achieved when the tester is truly neutral to the product.

January 2023 Log

2023-01-06T22:23:38.000Z

January 31st, 2023

Rebasing Large Patches

Rebasing steps after many merges from the base branch into the target branch:

Create a new branch for the rebasing work.
Do an initial rebase without modifying the branches history - the goal is to purely update the target branch to be based off the new base commit.
Compare the tree of original branch and the new "rebase" branch, ideally, if the original branch was up-to-date with the target branch, then the "rebase" and "original" branch file trees are identical.
Now that the rebase branch is based off the new base commit, do another rebase, making whatever changes you want to the branch.

Dark Mode

"Dark mode" should really be thought of as "dark gray mode". Some of these UI designers go full black, and in my opinion, it's even harder on the eyes than white.

January 23rd, 2023

A fun read on the history of the metric system and the US: It's been 230 years since British pirates robbed the US of the metric system.

January 6th, 2023

Code should read from the top down, and it should tell you as soon as possible when you can quit reading.

January 5th, 2023

Now that the value of posting on a "status update" site has lessened (Twitter), I'm happy with splitting my posts between two different mediums:

Topical content? Mastodon.
Other content? My notes.

February 2023 Log

2023-02-23T00:17:00.000Z

February 23rd, 2023

Steps to Overlaying One Image over Another (And a Log of How I Solve a Problem)

Start off with a div with two images in it. Both images are rendering, the "overlay" is under the base image as expected. Checkpoint.
Set CSS style on "overlay" image to position: absolute, top: 0, bottom: 0, observer "overlay" effect. Checkpoint.
Now pursue fitting image inside of box that takes 50% of document width.
1. First try setting containing div CSS style to width: 50%.
2. Notice overlay image is still taking 100% of parent's parent, but the "base" image is properly positioned. This is half of what we want.
3. Try using position: relative on overlay image. Doesn't work.
4. Research: "position absolute image does not use parent element box sizing".
  1. Click first link, most suggestions just suggest using pixel-wise adjustments, which we can't use.
  2. Notice some answers are suggesting parent container should use "relative" positioning. What is that about? Probably nothing, let's look into some other options.
  3. So far research seems to not be giving many great options...
5. Try adding CSS style display: inline-block to overlay image. This does nothing.
6. I noticed some of the other places where this worked, the parent container was a "flex" container. We can do this by setting the parent container's "display" property in its CSS to "flex" - so add this to the parent div CSS style: display: flex.
  - This has no noticeable effect.
7. Ok, playing around has so far not given me any good results. Let's return to the research I had open. The fourth result was from a blog post on "solodev.com". It too mentions setting the parent div positioning to relative. Maybe there's something to this? It's a quick thing to try, so let's try it.... success! Just what we wanted.

March 2023 Log

2023-03-13T04:35:39.000Z

March 12th, 2023

Fixing an Annoying Connection Issue

Currently really trying to nail down initializing a connection to a media server with project blue, so that it is portable and hopefully transitions easily to Jetpack Compose and navigation. I wonder what the best way is to initialize connection state? Here's my requirements:

If initializing the connection fails, need to send user to settings.
If no media server connection is selected, send user to the settings.
If initializing succeeds, continue normal execution.

This piece of code has also caused me numerous, hard to track issues for years, so if I could make as much of it as testable as possible, then this would be a win. My current idea is to do this:

Have an interface ControlConnectionInitialization that defines a single function, promiseInitializedConnection(libraryId: LibraryId): ProgressingPromise<BuildingConnectionStatus, IConnectionProvider?>, through delegation, I can build up different behaviors as needed.
Have a simple implementation of this interface that just proxies the connection:

class ConnectionInitializationProxy(
    private val manageConnectionSessions: ManageConnectionSessions,
) : ControlConnectionInitialization {
    override fun promiseInitializedConnection(libraryId: LibraryId): ProgressingPromise<BuildingConnectionStatus, IConnectionProvider?> =
        ProgressingPromiseProxy(manageConnectionSessions.promiseLibraryConnection(libraryId))
}

Have another implementation of ControlConnectionInitialization that handles error state and routes the user to the settings in failure. This will be passed an inner ControlConnectionInitialization, which we will assume is handling the basic connection (and maybe success case).
At the top level, have another implementation of ControlConnectionInitialization which handles the normal execution states, and delegates error-handling to the error-handling implementation.

I finished this work in this pull request.

April 2023 Log

2023-04-13T12:51:54.000Z

April 13th, 2023

Good source code requires other developers know as few assumptions as possible.

Drag and Drop Difficulties

2023-04-27T11:56:13.000Z

Drag And Drop Difficulties

It is surprisingly difficult to get drag and drop working in jetpack compose. I have had it working in most parts of the list for most of the week, but the first element causes the LazyList to readjust its bounds, causing absolute chaos. A fix I discovered in Google's examples partially helps, but still leaves the dragged element in limbo:

OSN 2023 Notes

2023-05-24T00:17:00.000Z

Open Source 2023 Notes

Inside ChatGPT

Lab651 and Recursive Awesome, Captovation - AI Solutions Development
Applied AI - 501c3 organization

GPT Releases

Version 1 - 117M parameters
Version 2 - 1.5B parameters
Version 3 - 175B parameters
Version 4 - 1T+ parameters

Wolfram One

Cloud/desktop hybrid, integrated computation platform
Similar to Jupyter notebooks
Lets you play around with GPT models (older than v3 and v4)

GPT 2

Always using the next highest probability word isn't always the best... using a "temperature" parameter, the model can be tweaked to sometimes choose words that aren't quite the highest probablity, leading to fewer run-on sentences.
Attention - when the model picks up on a higher probability and begins to focus in on it
Embeddings - training model on relationships between words (word pairs in a sense)
- Example: Munich - Berlin + France => Paris
- This can also be done for sequences of words and whole blocks of text
ChatGPT has learned syntactic grammar using embedding techniques
- When determing a sequence of words, it essentially follows a random walk through the syntactic grammar
Wolfram can break down the structure
OpenAI playground: https://platform.openai.com/playground
"How would you create a neural network model that would rule the world? Please write it out in small, specific steps."

Stable Diffusion

"Speaking plainly" to computers -isn't this programming?
Hannah Loegering - @fractalorange
Open Source AI:
- Deforum (Video, Image)
- Automatic1111/stale-diffusion-webai
- Langchain
- Simulacra and Simulation
- GPT4All Chat (text)
- Flowise/langchainJA-ui
@secondsightvisuals
Music is a 4-dimensional dataspace
Replicate - lucid sonic dreams, takes a source and produces an infinite sequence
phygital+ - create 3d-printed models
Can download stale diffusion and run locally
Midjourney runs over discord?
Luma AI - create 3D scenes and scan from 2D video
Kaiber - super easy AI animation
Wonder Dynamics - 3D character repalcement in 2D video
Deep Motion - 3D character rigging from 2D video
Runway ML - Full suite of video tools including their Gen1 and Gen2
Blockade Labs: text to 360 image
Simulacra - build 3D assets

Role of Generative AI in Healthcare

CTO of Virtuwell (Telehealth)
Virtuwell is not-for-profit?!

Care Delivery

Diagnosis prediction
Support clinicians by providing relevant medical info
Personalized health and wellness advice to individuals

Medicine

Personalized medicine: Forecast outcomes via patterns
Drug Discovery: identify possible new meds and predict compounds likely to be effective

Health Plan

Organize unstructured medical data

Virtuwell AI initiatives

Reduce over/under staffing by predicting the future
Predict surge traffic to website
Analyze patient data for systematic follow ups
Funneling relevant medical records
At-home kit for colon cancer screening and STI

Healthcare Companies in AI

Optellum: rules out harmless cases of lng canver via scans.
Ultromics: increases diagnostic accuracy of coronary heart disease from 80% to 94%
IDx-DR (now Digital Diagnostics): correctly identifies diabetic retinopathy by 87.4% (8% better than industry standard)
Beyond Verbal: Detecting Coronary Artery Disease by listening to voice

Future of Generative AI

If you are a large enterprise, you need to train your own LLM

Under-Engineering

Information / Technology impedance
- Programmers making wrong asusmptions based on limited informaiton
- Tribal knowledge lost over time and developer turnover
- Lack of documentation
  - Code not self-documenting
  - Unreadable unit tests
  - Distance between code and documentation (documentation is on a remote server away from source)
Self-inflicted complexity
- Ineffective bootstrapping: programmers bringing in their own toolsets instead of assessing what tools are best for their projets
- Programmers building their own frameworks
  - Overfitting
- Bug-fixes / rework
  - Bandaging code quickly instead of reworking code complexity
Under-engineering: act of explicitly engineering in a simplistic manner
Architecture should be as simple as possible
Developer documentation should be simple and accessible (developers should have their own set of documentation)
Coding should be simple, readable, and maintainable

Reduce Complexity

Find the most confusing concepts o fthe codebase
Document Confusion
Unit tests should be your guide on refactors
- Unit tests should be user friendly
Reverse code entropy - deleting code??
Identify:
- Challenging developer cadences
- confusing folder structures
- Hard-to-read / hard-to-write code
- Bad model or variable names
Put documentation next to code
Design for NOW, but with the future in mind
Ask what-if, but don't design for what-if in order to ensure you don't box yourself out
Push back on product feature work
Use 90% rule for generic/inheritance patterns
Provide code samples
Write comments first? (why not write unit tests first? :P)

IOT Eventing

General Workflow

Devices -> Event Ingestion -> Event Matching -> Event Delivery -> Event Actions -> Back to Device(s)

Design Constraint: Event Volume

Devices/Locations = 100
Max Events per Device: 10 events/s
SLO: < 1s response time from client controllers to devices

Evolution of Eventing

2011 - Monolithic, event-based architecture built around RabbitMQ
2013 - Monolith + sharding
2015 - Microservices: strong REST principles instead of Event Oriented Architecture, using Kafka instead of RabbitMQ
2015-2019 - Event pipeline: Kafka, Amazon EC2, SQS, oh my...
2019-current: one suscription system instead of a subscription per device type
- Move to a stateful subscription model
- One users events will always go through the same box
- Makes latency stable
Breaking down and logically dividing up work wihtin a system is critical

May 2023 Log

2023-05-28T00:17:00.000Z

May 28th, 2023

Most dependencies are just data. Data "repositories" are easier to fake than mock. Maybe mocks should just be used for hardware I/O?

June 2023 Log

2023-06-09T12:42:24.000Z

June 9th, 2023

The pareto rule strikes again - employees are at their best when they're working at 85% capacity, not 100% - https://hbr.org/2023/06/to-build-a-top-performing-team-ask-for-85-effort.

July 2023 Log

2023-07-31T02:08:58.000Z

July 30th, 2023

Programming Proficiency

To solve programming problems reliably one needs two skills:

Proficiency in set theory.
Specifying the correct behavior of code in tests.

Organization (naming things, type hierarchies, module placement) is also extremely useful for ensuring code maintainability, but it is a tangential skill to the first two skills.

Automated Project Publishing

2023-09-23T00:17:00.000Z

Automated Project Publishing

The idea: a small script that periodically runs, checking for changes to project readme's, and publishes updates to davidvedvick.info.

This script would need to reside in a-personal-site. Would need to be configurable so that it could accurately be run on a local machine but also on a build server.

Update 11/28/2023: I instead implemented this as GoCD pipeline that I run on-demand, and it is glorious.

August 2023 Log

2023-09-23T23:19:43.000Z

Solid Freeform 2023 Notes

From August 14-16, 2023 I attended an academic conference on 3D printing research, below are my notes.

Technion Additive Manufacturing Center

Current geometric design pardigm ha sbeen with us for over a decade
V-rep operations:
- Filleting and rouding
- Mixed symbolic/numeric computations over multivariate (and V-rep) splines
https://csaws.cs.technion.ac.il/~gershon/irit

In-Situ Process Monitoring in AM

Michael J. Heiden

Purpose, Motivation

Failure mode analysis (ie spike in oxygen)
Reduce coupon inspection
Runs in parallel with the build process

Detection Methods and Processes

Optical IR
Use the Peregrine machine learning model from Oakridge
Use multi-modal data (thermal imaging/thermography, high speed cameras, spectroscopy, acoustic monitoring)

Using the Data to Create Useful 3D Digital Twins

Show discrepancies between what is supposed to be printed and the actual

Future Targets

Real time monitoring
Closed lop control for defect correction (this is what we do!)

Machine Learning Applied to Process Monitoring for Laser Hot Wire Directed Energy Deposition

Carnegie Mellon University

Comparison with Laser Powder Bed Fusion

Under acceptable conditions, melt pools are not stable
Monitoring of rare unwanted events such as spatter requires significant ML traning (1k-10k hand-labeled images)

Laser Hot Wire Additive Manufacturing

Well behaved melt pools under normal conditions
Can monitor entire buildds in real time
Approach: detect unsteady behavior of the melt pool, don't attempt to learn the appearnce of irregular events

Methodology

Many flaws exist across multiple frames, so a time dependent analysis is beneficial
Long Short-Term Memory networks are able to learn time dependencies in video data
Use previous frames to predict future frames (about 10-20 frames of past history)
Capture a regularity scorePredicition: within 5-10 years we will see fully sensed and automated DED systems

Known Flaw Types

Stable Deposition
Melt pool oscillation
Arcing
Wire stubbing
Wire dripping

Summary and Conclusions

ML model detects unsteady behavior, which is indicative of process instability (unlike LBPF)
Prediction is that DED systems will be deployed with fully automatic quality control in next 5-10 years

Area Printing

Area printing is stamping on the powderbed
Seurat is the company that developed this technology

Rethinking Additive Manufacturing

DfAM transcends disciplinary boundaries
Traditional manufacturing informs our design sensibilities
Evaluate design using consensual design techniques
DfAM increases as experience increases
Restrictive DfAM: "Can we print it"
Opportunistic DfAM: "Should we print it"
Unlearning requires designers to identify good DfAM solutions
VR can help with DfAM
Use VR for simulating a printer in test?
- Probably not super beneficial for our needs

Co-deisgn of 3D Printing

You cannot monitor your way out of trouble: need all the insights possible from in-situ and operando monitoring.
In aircraft manufacturing: "Anything that allows you to gain efficiency is worth the manufacturing cost"
Diffusion Modeling is not sufficient for AM Heat Exchangers
- Use heat exchangers used with solar energy?
- Alternate technology: diffusion bonding
Improved heat exchangers reduces defects?

Physical Validation of Job Placement Optimization in Cooperative 3D Printing

Traditional vs Cooperative 3D printing
- Traditional: gantry systems
- Limited in scalability and flexibility
Partitioning Strategy: Chunking
- First chunk into layers (Z-Chunking)
- XY-Chunking: chunk adjacent chunks at an angle to facilitate bonding of chunks
Use grid search algorithm (A* Path Planning) to plan robot movement
- If there are two robots that are going to take a path at the same time, apply a conflict avoidance algorithm
AMBOTS C3DP
When a robot moves to a new location, it requires manual calibration

Time Optimal Path Planning for Heterogenous Robots in Swarm Manufacturing

Continuous spatial profile with arbitrary robot gemoetry that includes orienatation
Dynamic environment with arbitrary number of obstacles
Time-optimal solution for multiple agents
Projecting Dynamic Obstacles
- Use "safe intervals" to reduce number of computations
- Based on safe intervals, split the configurations based on what has more than one safe interval
Limitations:
- Does not make real-time adjustments
- Truly centralized optimal planning scales exponentially with the number of agents
Open questions:
- How does shape discretizaiton impact solution quality?
- What is the upper number of agents before it is too computationally expensive?

Layer Wise Prediction of Microstructural Evolution

Predict grain size and melt-pool depth using thermal model features
As structure grows, cooling rate decreases
Prediction using physics-guided machine learning (SVM models)
- Predict Meltpool Depth
  - Not inuitively explained by process parameters
- Thermal Feature Correlate to Grain Size
  - Grain size predicted with 90% F-Score
Cooling rate also decreases with heat build-up

Post Superficial Temperature Monitoring During Additive Manufacturing

CNN goal is to produce predicted temperature of build
Best results come from combining a machine learning model, in situ monitoring, and sensors
Normal Data + Wall Simulation as inputs gives best ML performance on experimental data
In Situ Sensors + ML models as a "Digital Twin" of how the part will be produced

Optimal Control of Wire DED Systems

Modeling of a dynamic system usually using ODE
Optimal Control Theory - https://en.wikipedia.org/wiki/Optimal_control

Framework for Physics Guided Machine Learning

Process variations are high in AM
PSP: Process-structure-property

PSP Linkages for In-situ Data

Predictive Melt-pool Modeling
- Multi-layer model produced best results
Predictive Pore-structure Model
Predictive Surface-height Model

AI Driven In-Situ Monitoring

Intrinsic Keyhole Oscillation

Keyhole: a puncture in the powderbed that leads to an unexpected cavity ("keyhole pore") in the powderbed

Combine X-Ray imaging and Thermal Imaging
Intrinsic Keyhole Oscillation
- Surface tension and coil pressure
- Liquid flow on the outside of the meltpool increases keyhole size
- Lower than 30KHz
Perturbative Keyhole Oscillation
- Greater than 40KHz

Gradient-weighted Class Activation Mapping (Grad CAM)

Predict where keyholes will form using an ML model, avoiding further X-Ray synchotron experiments
An input to the trained model is a simulation of the build

PRISM: Process Parameter Optimization for Selective Manufacturing

Goldilocks zone:
- Not enough: lack of fusion
- Too much: keyhole formulation
Use machine learning to determine proper process parameters!
Goal is to achieve high density, assume density is a surrogate for:
- CTE (Coefficient of thermal expansion)
- Elastic modulus
- Strength
- Toughness
Data will be published and open source
ML Driven Design of Experiment
- Latin hyper cube sample generation
- Predict Printability using tree algorithm (bounds determined by expert)
- Predict density using tree algorithms (XGBoost)
Select candidates: diversity (determined by L2 distance), quality, and random sleection
Used FLAML to automate experimentation
Would probably need to re-train per material type

FAIR Knowledge Management System for Additive Manufacturing

AMMD.nist.gov, AMBench2022.nist.gov
ASTM F42 - working group developing data models to represent AM

Unconventional Data Sources for Market Intelligence

Aachen Center for AM
Market intelligence uses external data over internal data (patent databases, social media, etc.)
Databases used for research: Amadeus, LinkedIn, Scopus

Digital Twins

Part qualification is manual and slow
Can digital twins help understand the process to manufacturing property map?
Direct Ink Write
Using robotic automation to generate large amounts of parts and data

Executable for Avant Garde Laser Exposure (EAGLE)

Common command interfaces
Ability to support any input file
Plugin support
Process Buckets
Limited interference with machine
Common Build Data Storage
- SQL Database on machine or network
Print Process Flow:
- Pre-Process
- Layer Process:
  - Verify -> Scan -> Characterize -> Recoat
- Post-Process
EAGLE is written in Rust and Javascript using Tauri
- Designed to support print files > 100GB

Direction not intention determines destination

In-Situ Monitoring Using Neutron Rays

Neutrons have high penetration in metals
Different contrast from X-Rays
Phase evolution
In-Situ Laser Metal Deposition
- Completmentary to lab and synchotron experiments
In-Beamline Strain Measurement
Neutrons are non-destructive, tri-axial, and sub-surface
Additive has a much wider distribution of gamma prime and gamma double prime sizes

X-Ray Compute Tomagrphy

Determine powder size because that's always going to be stuck on the surface
Could minimum powder size (and laser amplitude?) define minimum defects size?

SATURN

SCT and MPM Data

Lack of fusion and keyhole are two major issues (laser power)
Rnadom forest prediction works with decent acccuracy
U-net model?
Some defects will heal automatically, and don't need to be treated
Non-balanced gain control introduces saturation in the photodiodes
OEM gives a graphical representation of the data, not a tabular or formatted version
Photodiodes operate at >11MHz
Sensor captures images at 400um resolution

Intelligent Process Control

Using FPGA to provide faster response times
Goal is to catch a defect within the transient state (10-20us), they've (potentially) achieved nanosecond response times

High precision measurement of Melt Pools

FPS of 40,000
Resolution: 896 x 176 pixels

End-to-End AI Models for Error Detection

Current issue - solutions are not general
Matta (Cambridge company), Grey-1 AI Copilot for AM
Multi-head residual attention convolutional neural network:
- Develops its own masks to determine where to pay attention

November 1st, 2023 Log

2023-11-08T19:17:49.000Z

November 29th, 2023

A core component of learning is separating signal from noise on a given subject. The corollary is that a core component of teaching a subject is informing the student which parts are noise; the signal falls out from this.

November 1st, 2023

Having dealt with C# DLL hell for years, and then going through the equally hellish dotnet HttpClient fiascos, and now struggling with adopting ES modules in a Typescript library, I am beginning to believe that Microsoft has a department focused on making module resolution a living hell for anyone who uses their tools.

The Interaction State Primitive

2024-01-27T17:47:48.000Z

The Interaction State Primitive

I've been developing UI's in some form or another for about 25 years. It's taken nearly that long to realize the basic primitive of dynamic UI's: what I call the "Interaction State" primitive. The Interaction State primitive has these rules:

The current state of the property can be accessed via a normal get accessor. In Java, this might be a method with a signature like T getValue(). Sometimes this is called a snapshot, but I prefer the more direct terminology of state. In a language with more syntactical magic available, it can be done via something like a get accessor.
Its value can be updated via a normal set accessor. In Java, this might look like setValue(T value). Again, in other languages, syntax magic can make the write access more terse.
Updates to the property's state are observable. Below, I will cheat and use the ReactiveX flavors to achieve this.
setValue(T value) only notifies observers the value is updated when the new value is not equal to the existing value. This should follow normal equality rules of the language.

I am not the first to make this observation; KnockoutJS, which I used c.a. 2014, had observables in Javascript, and Rx.Net and other ReactiveX flavors have been around for quite some time, with the BehaviorSubject<T>, which has the above semantics, but with slightly contorted syntax. However, in my opinion, all of these languages and libraries don't make it plain that these are the rules they're following. Perhaps the authors of these API's think these rules are obvious and don't need to be broadcast. However, these rules weren't made plain to me until I came across the StateFlow type in Kotlin: upon observing it's simplicity, the lack of too much magic or layers of obfuscation, this raw form of the Interaction State primitive made it all obvious to me.

What benefits does this Interaction State primitive give?

When used as the main representation of the data state in a View Model, they're easily testable; the current state of the property can be taken just by calling getValue(), and if you want to validate how the property changes over time, you can easily do that too.
When the observable portion is implemented using something like the Reactive extensions, you can observe its value over time with endless numbers of operators. Using something very generic like Reactive extensions instead of something like StateFlow leaves you very free of any assumptions made about the runtime or environment; for example, you don't have to mess with coroutine contexts or anything like that.
Integrates very nicely with dynamic UI frameworks; React obviously has its state variables, Jetpack Compose has the magical stateOf and mutableStateOf, and C# has the INotifyPropertyChanged magical interface, and the Interaction State primitive can integrate very nicely with all of them! It also integrates well with something like WinForms.

I want to show some examples of how this primitive can be used in different languages, with a fairly simple use case: given expenses and incomes, display the networth.

Kotlin and Jetpack Compose

Here's an example in Kotlin, integrating with Jetpack Compose:

// The read-only interface for the Interaction State Primitive
abstract class InteractionState<T> : Observable<NullBox<T>>() {
    abstract val value: T
}

// A mutable implementation of the read-only interface for the Interaction State Primitive.
class MutableInteractionState<T>(private val initialValue: T) : InteractionState<T>() {

    // RxJava has the unfortunate design decision of nulls not being allowed as values, so we 
    // box the value to allow nulls.
    private val behaviorSubject = BehaviorSubject.createDefault(NullBox(initialValue))

    override var value: T
        get() = behaviorSubject.value?.value ?: initialValue
        set(value) {
            if (behaviorSubject.value != value)
                behaviorSubject.onNext(NullBox(value))
        }

    override fun subscribeActual(observer: Observer<in NullBox<T>>?) {
        behaviorSubject.safeSubscribe(observer)
    }

    fun asReadOnly(): InteractionState<T> = this
}

class LiftedInteractionState<T: Any>(source: Observable<T>, private val initialValue: T) : InteractionState<T>(), AutoCloseable {

    private val behaviorSubject = BehaviorSubject.createDefault(NullBox(initialValue))
    private val subscription = source.distinctUntilChanged().subscribe { behaviorSubject.onNext(NullBox(it)) }

    override val value: T
        get() = behaviorSubject.value?.value ?: initialValue

    override fun subscribeActual(observer: Observer<in NullBox<T>>?) {
        behaviorSubject.safeSubscribe(observer)
    }

    override fun close() {
        subscription.dispose()
    }
}

class MoneyViewModel(accountManager: ManageAccounts) : ViewModel() {
    val expenses = MutableInteractionState(0.0);

    val income = MutableInteractionState(0.0);

    val networth = LiftedInteractionState(
        Observable.combineLatest(expenses, income).map { expenses, income -> income - expenses },
        0.0);

    suspend fun loadAccount(int accountId) {
        var account = accountManager.loadAccount(accountId);
        expenses.Value = account.Expenses;
        income.Value = account.Income;
    }
}

// easily map MutableInteractionState to mutableStateOf(...)
@Composable
fun <T, S : MutableInteractionState<T>> S.subscribeAsMutableState(
    context: CoroutineContext = EmptyCoroutineContext
): MutableState<T> {
    val state = remember { mutableStateOf(value) }
    DisposableEffect(key1 = this) {
        val disposable = subscribe { state.value = it.value }

        onDispose {
            disposable.dispose()
        }
    }

    LaunchedEffect(key1 = this) {
        value = state.value
        if (context == EmptyCoroutineContext) {
            snapshotFlow { state.value }.collect {
                value = it
            }
        } else withContext(context) {
            snapshotFlow { state.value }.collect {
                value = it
            }
        }
    }
    return state
}

// The Compose view
fun MoneyView(viewModel: MoneyViewModel) {
    with (viewModel){
        var expensesState by expenses.subscribeAsMutableState()
        StandardTextField(
            placeholder = stringResource("Debit"),
            value = expensesState,
            onValueChange = { expensesState = it }
        )

        var incomeState by income.subscribeAsMutableState()
        StandardTextField(
            placeholder = stringResource("Credit"),
            value = incomeState,
            onValueChange = { incomeState = it }
        )

        val networth by networth.subscribeAsState()
        Text(networth);
    }
}

Typescript and React

Here's my usage in Typescript/React:

// Build up the type definitions
export interface InteractionState<State> extends Subscribable<State> {
    get value(): State;
}

export interface UpdatableInteractionState<State> extends InteractionState<State> {
    set value(state: State);
}


// With Typescript, we have the advantage that we can just inherit from the existing `BehaviorSubject` and here
// make `value()` read-only via interface. Of course it's not enforced in the runtime, but it's good enough for us.
class MutableInteractionState<T> extends BehaviorSubject<T> implements UpdatableInteractionState<T> {

    constructor(initialValue: T) {
        super(initialValue);
    }

    set value(value: T) {
        this.next(value);
    }
}

class LiftedInteractionState<T> extends BehaviorSubject<T> implements InteractionState<T> {

    constructor(observable: Observable<T>, initialValue: T) {
        super(initialValue);
        observable.subscribe(this);
    }
}

export function liftInteractionState<T>(observable: Observable<T>, initialValue: T): Observable<T> & InteractionState<T> & SubscriptionLike {
    return new LiftedInteractionState(observable, initialValue);
}

export function mutableInteractionState<T>(initialValue: T): Observable<T> & UpdatableInteractionState<T> & SubscriptionLike {
    return new MutableInteractionState(initialValue);
}

export function useInteractionState<T>(interactionState: InteractionState<T>): T {
    const [state, setState] = React.useState(interactionState.value);

    React.useEffect(() => {
        const sub = interactionState.subscribe({ next: setState });
        return () => sub.unsubscribe();
    }, [interactionState]);

    return state;
}

export function useMutableInteractionState<T>(interactionState: UpdatableInteractionState<T>): [T, Dispatch<SetStateAction<T>>] {
    const state = useInteractionState(interactionState);

    return [
        state,
        (stateOrAction: SetStateAction<T>) => {
            if (stateOrAction instanceof Function) {
                interactionState.value = stateOrAction(interactionState.value);
                return;
            }

            interactionState.value = stateOrAction;
        }];
}

export class MoneyViewModel {
    readonly income = mutableInteractionState(0);
    
    readonly expenses = mutableInteractionState(0);
    
    readonly networth = liftInteractionState(
        combineLatest([this.income, this.expenses]).pipe(map(([i, e]) => i - e)),
        0);
}

const vm = new MoneyViewModel();

export function MoneyView() {
    const income = useInteractionState(vm.income);
    const expenses = useInteractionState(vm.expenses);
    const networth = useInteractionState(vm.networth);

    return <div>
        <input type="text" value={income} onChange={e => vm.income.value = Number.parseFloat(e.target.value)}/>
        <input type="text" value={expenses} onChange={e => vm.expenses.value = Number.parseFloat(e.target.value)}/>
        <div>
            <h3>Networth:</h3>
            <p>{networth}</p>
        </div>
    </div>;
}

C# and WPF

interface IInteractionState<T> : IObservable<T>
{
    public T Value { get; }
}

// Implementing INotifyPropertyChanged as well allows it to be used with WPF/XAML bindings
class MutableInteractionState<T> : IReadOnlyObservableProperty<T>, INotifyPropertyChanged, IDisposable
{

    private readonly BehaviorSubject<T> subject;

    public event PropertyChangedEventHandler PropertyChanged;

    public MutableInteractionState(T initialValue)
    {
        subject = new BehaviorSubject<T>(initialValue);
    }

    public T Value
    {
        get => subject.Value;
        set
        {
            if (!EqualityComparer<T>.Default.Equals(value, subject.Value))
            {
                subject.OnNext(value);
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
            }
        }
    }

    public IDisposable Subscribe(IObserver<T> observer) => subject.Subscribe(observer);

    public override void Dispose() => subject.Dispose();
}

// A read-only observable
class LiftedInteractionState<T> : IReadOnlyObservableProperty<T>, INotifyPropertyChanged
{
    private readonly BehaviorSubject<T> subject;
    private readonly IDisposable sourceSub;

    public event PropertyChangedEventHandler PropertyChanged;

    public LiftedInteractionState(IObservable<T> source, T initialValue)
    {
        subject = new BehaviorSubject<T>(initialValue);
        sourceSub = source.Subscribe(v => Value = v);
    }

    public T Value
    {
        get => subject.Value;
        private set
        {
            if (!EqualityComparer<T>.Default.Equals(value, subject.Value))
            {
                subject.OnNext(value);
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Value)));
            }
        }
    }

    public IDisposable Subscribe(IObserver<T> observer) => subject.Subscribe(observer);

    public override void Dispose()
    {
        sourceSub.Dispose();
        subject.Dispose();
    }
}

class MoneyViewModel
{
    private readonly IAccountManager accountManager;

    public MutableInteractionState<decimal> Debit { get; } = new(0);

    public MutableInteractionState<decimal> Credit { get; } = new(0);

    public IInteractionState<decimal> Networth;

    public MoneyViewModel(IAccountManager accountManager)
    {
        this.accountManager = accountManager;
        this.Total = new LiftedInteractionState<decimal>(
            this.Credit.CombineLatest(this.Debit).Select(tuple =>
            {
                var (credit, debit) = tuple;
                return credit - debit;
            }),
            0);
    }

    public async Task LoadAccount(int accountId) {
        var account = await accountManager.LoadAccount(accountId);
        Debit.Value = account.Debit;
        Credit.Value = account.Credit;
    }
}

<Window>
    <Grid>
        <TextField Value={Binding Debit.Value} />
        <TextField Value={Binding Credit.Value} />
        <TextLabel Value={Binding Networth.Value} />
    </Grid>
</Window>

In my opinion, removing the obscurity around this primitive has a similar effect to understanding the Promise; it opens up and simplifies a whole class of programming problems: with the Promise, a single definition is wrapped around building asynchronous functions and receiving their results, likewise, for the "Interaction State" primitive, a single definition is given to making a UI that reacts to inputs agnostic of the source; in other words, regardless of whether the UI needs to respond to user input or the UI needs to respond to asynchronous calls, the situation will be handled in the same way by the "Interaction State" primitive. It also enables a programmer to use it for purposes beyond what the implementations above restrict the user to; for example, I've used the Kotlin implementation in both Android XML views and Jetpack Compose, likewise, I've used the C# implementation for common code between WinForms views and WPF views. This allows my view models to remain stable, while only the decoration is updated with new binding syntax.

March 5th, 2024 Log

2024-03-05T20:29:16.000Z

March 23rd, 2024

Bittorrent is Dying, NFT's were dumb, but together they could be great?

This is probably an already explored idea, but I quite like the idea for digital art of some sort of proof-of-sale/proof-of-ownership system that uses a git-like (or blockchain-like) structure, which contains magnet links for that digital art, with the digital art itself remaining unencrypted. I think something like this would give society a neat way to appreciate artists for their work without having to lock down said work. Maybe this is what NFT's already are, I don't know!

March 18th, 2024

A defining feature of an asynchronous operation is that it is cancellable.

March 5th, 2024

Good programing is more about good judgment than anything else.

April 9th, 2024 Log

2024-06-18T03:53:59.000Z

April 9th, 2024

Rust seems like the perfect language for an LLM-driven programming agent, because the compiler has so many safeguards, that often the best way to build the best program is often to just iterate until your program passes the compilers tests anyways.

June 17th, 2024 Log

2024-06-18T03:54:33.000Z

June 17th, 2024

Targeting Multiple Form Factors on Android

If you'd want to target multiple form factors on Android for a single application, you suffer from a case of too many options:

Provide the same app:
- Views that adapt to different view dimensions.
- Views that render differently depending on flags given during the launch of the application (typically via intent).
Provide different apps:
- Different product flavors or different modules:
  - Different application IDs.
  - Different version codes.

This means there are 6 (2 + 2*2) possible ways of providing a different application based on the deployed form factor. So how to choose the best?

First off, the "different apps design" seems mostly intended for completely different applications that share the same codebase; the fact that you can use it for different form factors seems to just be a nice side effect. This means that this approach really works best with different applications - with different application IDs, you don't need to worry about collisions when providing application artifacts on Google Play. The downside is that this leaves you with two separate apps as far as Google Play is concerned, or two different version code tracks. If you take the "different version code" and later consolidate your handheld and TV apps, with the TV app being on the "higher" version code track, users will have to for example uninstall the existing TV application. One thing to be aware of with this approach is that once set-up in the Google Play store, it is difficult to reverse.

The other approach is to modify your views given different view dimensions or different Intent information. For TV, for example, this can be discerned by launching a special activity that is filtered on the android.intent.category.LEANBACK_LAUNCHER intent category. While having a single app makes publishing to the app store easier, it does leave both your TV users and your handheld users with the whole app, even though they may not use large swaths of it. Sharing views between TV and handheld is harder than it seems, at least with Jetpack compose, as the API's between touch and D-Pad navigation are largely separate.

Regardless of approach, it feels like swimming upstream trying to have the same app in different form factors. The ideal would to be able to produce different applications per form-factor that can share application ID and version code. Absent that, I think the best approach is unfortunately to maintain a single application.

Distributed Large Language Models

2025-01-05T00:59:40.000Z

Distributed Large Language Models

LLM's have proven their utility for generating small scripts. You'll often read comments along these lines on programming forums these days:

Sure LLM's can generate little scripts but they can't create real programs...

I think this is largely true; however, this is actually useful in "real" programs — the "scripting" ability combined with auto-complete can definitely contribute to developing a full-sized program. Already, tools like Copilot are taking advantage of this ability. This is also generally useful (although it comes with some major caveats in my opinion).

Since LLM's are so great at condensing a large amount of information into a relatively small model that can be queried with natural language, like many others, I worry about the loss of great sources of information like Stack Overflow. Stack Overflow's advantage over an LLM is that it's constantly gaining new information, and it's generally fed by great feedback loops that encourage contributing new information. Of course, this has its own issues, but in general, I think that holds.

However, part of me feels like the philosophers of old, concerned that this new-fangled writing technology was going to reduce human intelligence since we no longer would need to learn through discussion. So, I think it's important to think of what will come next, now that we can in some ways have a miniature static Stack Overflow on our PC's: will we have shared models that can send information back to a host, feeding in new tips, fixes, etc.? I fear this being centralized by commercial entities, and I think even Stack Overflow is trying to build something like this. OpenAI and Microsoft are already using feedback mechanisms.

Would it be possible for the programming community to do P2P model training and inference? This sounds great, but how do we develop and use shared models that have minimal or no quality control? Does or can a community form around a P2P model that corrects its training? How does a community pay for the training? Is it distributed, like folding@home but for programming help? Building a DNN model isn't just about dropping in a bunch of data and hitting the train button, it also involves a lot of decisions on the trainer: choosing appropriate number of layers, how many iterations to train, and more. This might need to be static to some degree with a shared community model.

Minnesota Code Freeze Conference Notes

2025-01-17T19:28:02.000Z

Minnesota Code Freeze Conference Notes

My notes from the 2025 Minnesota Code Freeze conference that took place at the University of Minnesota.

Working Effectively with Legacy Code

Michael Feathers (r7k)

Test-Driven Architecture (like TDD but for architecture).
Hyrum's Law: Any behavior you expose on an API will become depended upon even if it's not intended.
Knowledge tends to dissipate over time (think music popularity reduction over time, for example, the ragtime of the 1920's).
Galileo's scaling law (the square/cube law) - structure must change as things grow:
- Initially named after the concept that as an object grows its volume grows faster than the surface (n^3 > n^2).
- However, applies to other scaling concerns, for example, you can't build a skyscraper with wood.
- With graphs, as they grow, you need to break them into smaller graphs to manage them effectively.
- Understanding this tension can improve design.
Miller's law - humans can track 7 +/- 2 items
- This relates to class design, a class with 20 methods is much harder to track than a class with around 7.
"The Principle of Deliberate Context" (coined by Michael Feathers):
- Systems should be designed with intentionally bounded contexts that are optimally sized for human cognition.
Robustness principle: be liberal in what you accept and conservative in what you produce.
A potential issue with AI is when it generates things that we don't understand.

Infrastructure as Code Anti-Patterns

Jason Baker (Director of Cloud Operations at Civix)

Thought on anti-patterns: every anti-pattern started as a pattern with good intentions.
Why do infrastructure as code anti-patterns exist?
- Senior tech leadership usually is promoted through software not infrastructure (citation needed).
- Defining infrastructure as code is immature compared to software development (isn't infrastructure as code software development?).

Cloud Cowboys

Creating cloud infrastructure manually (using a web console) instead of using code.

Muti-Tool Madness

Using too many tools to define the infrastructure.
Increased complexity, risk, and toil.
Picking a consistent tool is more important than pick the best tool.

Partitioning infrastructure projects by infrastructure type or environment instead of by context.
Building all the environments

Using a single infrastructure template to build out all environments.
Templates should be environmentally agnostic.
Infrastructure changes should be promoted using the same process as normal software.

One repo to rule them all

Defining all resources using infrastructure code in one monolithic infrastructure code repository.
Can introduce undesirable coupling.
Partition infrastructure code by services.

Using DRY With Infrastructure

All software problems can be solved with another layer abstraction, except for the problem of too many layers of abstraction.
Taking an imperative approach to building infrastructure instead of a declarative approach.
Coupling vs. cohesion

Modularize all the things

Same as above.
Enforce the updating of module versions across projects, allowing no more than for example 2 versions in use.

The infra team

All infrastructure code has to be defined by an infrastructure team.
Reinforcese the traditional division between developer and infrastructure operations.
A single team becomes a major bottleneck for infrastructure work.
In high-performing organizations most of the infrastructure code is defined by software developers and co-located in application repositories.

All security related infrastructure code changes must be implemented and approved by the secuirty team.

Finite State Machines and AI

Adam Terlson (https://github.com/adamterlson/AgenticStateMachines)

Using state machines to control AI agents.
X State: state management and orchestration library
Model-based testing of state machines
His AI Agent definition:
- Autonomous - operates independently, making decisions without constant human input
- Goal-oriented - achieves specific objectives
- Context-aware
- Collaborates
- Interactive
- Persistence - retains memory of past interactions and data.
- Adaptive
Agentic Systems:
- Actors provide autonomy and communication.
- State machines provide structure, enforce predictable behavior.
- AI provides adaptability.
Patterns:
- Tool use
  - Available tools given to LLM.
  - LLM returns JSON object describing a method (tool) call.
  - Expected next message is tool response.
- Human in the Loop (tool approval, if tool is expensive).
- Feedback: one oagent receives the output of another agent and gives feedback on how to improve.
- Collaboration: multiple specialist agents working on a broader goal where each agent owns a slice of the broader task.
- Orchestration: Planning agent dynamically routes to the next agent based on current context.
- "Chartering": state machine defined by LLM.
Advantages over industry tools?
- (LangGraph and competitors)

Evolveable Architectures

Rebecca Parsons

Conway's law - the systems you build will reflect the dysfunction of your organization.
Last responsible moment - wait to make decisions until the last possible moment.
How do we build code that is auditable?
How do we build code that increases code quality?
Contract testing allows developers to ignore each other.
Use AI for contract testing?
LLM hallucinations are a feature, not a bug. How are you supposed to generate something new if you never make something up? The question is whether there are ways to bound the hallucinations (yes, with temperature).
How do you test non-deterministic systems?

Monolith vs. Platform vs. Serverless

Corwin Diamond

This talk was generally biased against monoliths (seemed to imply a definition of a monolith as a giant legacy application, in something like an older ecommerce server application).
CAP Theorem:
- Consistency - works correctly.
- Availability - always works.
- Partition Tolerance - works across different partitions.
- You can pick 2.
Distributed CAP: different services/teams within your ecosystem will have different CAP requirements.
Multi-cluster platforms...
- Need to solve data replication.
- Sounds like classic SOA/microservice problems.
Cellular architecture...
- Platform monoliths.
Modularize abstract abstractions.
Minimize different types of deployment processes.
Remove requireemnts that aren't required.

Panel

David Laribee, Rebecca Parsons, Michael Feathers

Remote work:
- How can we maximize the effectiveness of in-person time?
- Shoud do hybrid meetings remote first.
- Important to work on things together with remote work.
- Create venues where smaller collaborations can occur.
- Times when we get together should be treated as precious and valuable.
- Is the problem encouraging people to value social connections?
Modular Monoliths:
- Return to simplicity.
- Look into testcontainers.
- It is important at the early stages of a product development to develop a well-structured monolith.
- Chris Richardson has good ideas on microservices.
- Event-driven applications can be done in process (and I do).
Functional programming:
- "The little lisper", "the little schemer" books.
- If one spends too much time in the OOP world, it can become difficult to understand functional programming.
- More people are recognizing the benefits of functional programming.
How do we discern when we should adhere to new programming principles vs traditional principles?
- With low-code/no-code, you can get started very easily, but it's hard to scale to complex problems.
  - It's easy to solve 80% of the problem, hard to solve the remaining 20%.
- Be very cautious about de-scaling your development.
- Where have all the mid-level engineers gone :D.
Is agile dead?
- Agility was kind of jettisoned, and "agile" became a management practice.
- Good technology (and good process?) disappear, they just become standard operating procedure, like small commits, TDD, etc.
- There are different product domains: Simple, Complex, and Chaotic. Which domain your product fits in determines how "agile" you need to be.
3 things developers can do to stay current:
- Need to start using AI.
  - How are they going to make money off of it?
- Everyone is using AI today which differs from the prior AI hype cycles of the 60's and 80's.
  - And problematically, most people do not have a strong mental computational model that matches how it really works.
- AI is good at ideation. It can also help increase your skill at asking questions.

OSN 2025 Notes

2025-05-29T00:17:00.000Z

Open Source 2025 Notes

Throwback Thursday: Old School Optimization Using Newfangled Machine Learning

Linear Programming

"Programming" in the sense of scheduling.
Inequalities carve out regions of space. These are called "constraints".
Objective function: goal we are trying to maximize.

Linear Optimization Facts

Solvable when bounded.
Min-Max duality.
- As an example - RPGs: Max strength == min weakness
Deterministic - guarantees best answer given the input. Is susceptible to garbage input.

When to use

Making the best choice out of many available while satisfying constraints.
- Resource allocation.
- Matching.
- Routing problems.
- Inventory decisions.
Best fit for batch decisions under constraints.

Expected Outcomes

Better use of resources.
Stable operations planning.
- Better inventory management

Pros of Linear Programming

Measured risk, explainable, and respects your contraints. Can be built quickly with a small team.
Plays nice with forecasted values: making best prediction with the data available.
Any vertex of the feasible region has a cone of normal vectors where it is the optimal solution.
Strength of forecast affects the feasible region.

How to Make One?

Pyomo functions like an ORM for interfacing with solvers.
CBC (COIN-OR Branch Cut) to solve.

React at Work Post-Create-React-App

Provided testing, bundling, and a dev server built-in.
"Kill it with Fire" book looks interesting.
Create React App officially deprecated in February 2025.
- React 19 doesn't work well with it.
- React is slowly becoming its own framework instead of just acting as a component in a bring-your-own-framework model.

Alternatives

Next.js

Cons:

Tight coupling of backend and frontend.
Built-in server runtime.

Remix

Also tightly coupled.
Gnarly nested routing structure.

Bun

Really fast bundler.
Too much magic.
Incomplete ecosystem compatibility.

Vite

Fast, flexible, and friendly.
Pretty easy to migrate from CRA.
Static by default.
Unbundled dev server, optimized builds.
Can use existing rollup plugings.

Open Source Tooling and Best Practices to Improve Vulnerability Management

VM: Vulnerability Management
--Identification -> Reporting -> Evaluation -> Prioritization -> Remediation -- ∧ | | ∨
Competency trap: people don't use new tools because building competency in a new tool is challenging.
Mend Renovate: formerly Renovate.
Renovate bot can work off of dependencies defined in comments in a dockerfile.

Beyond the Chatbot: Delivering Business Value with LLMs

According to IBM "Institute of Business Value", only 25% of AI initiatives have delivered expected ROI.
- 16% have scaled enterprise wide.
- IBM's Advice: ignore FOMO, lean into ROI.
When to chatbot:
- Onboarding users (employees/customer) to complex systems.
- When users are lost, confused, or not even sure what they need.
Need metrics
- conversion rate
- % requests routed to a human
- manual time saved
- response/execution times.
When not to chatbot:
- Simple forms
- When users are experts
- LLM Assisted Automation (agents) can provide value by performing tasks on triggers.
- Using AI to capture business that you don't have the number of people to take in the business?!?!
Solving problems with GenAI:
- Classifying unstructured data.
  - What kind of document is it? What needs to be done with it?
- Convert unstructured so structured data?
  - Parsing quote requests, emails, etc.
- Translate similar data between systems:
  - Referencing information from external vendor systems.
Why was something not already automated?
- Complex SOPs (Standard Operating Procedures).
- Unstructured data
- Parsing information from multiple internal/external services

Measuring GenAI Solutions

LLM Evals

"Answer true or false" is the key.

Example:

SYSTEM: Act as a metallurgy expert. Do not explain your answer. Answer true or false.

USER: Steel is an alloy of iron and carbon?

Easy to apply to any business domain. Ask experts: what are the toughest questions you're asked? What are the perfect 20 year veteran answers? Then let the expert decide when the AI is trustworthy enough.

Metrics Driven Development

Answer correctness
- True/false, multiple choice questions
- More complex questions:
  - Determine ground truth
  - Take intersection of model answers and ground truth and divide by intersection + model + ground truth.
    - AnswerIntersections / (AnswerIntersections + Ground Truth + Model Answers)
Faithfulness - degree to which outputs align with facts
Relevancy
Context recall
Arize Phoenix: LLM evaluation tool
guardrailsai.com

These tools are generally used to test existing LLM's, not to fine tune or create a new model. Most things that are changed by the LLM implementer are the context that is fed in, or the prompt that is given.

Against Object Pools

2025-06-22T13:39:56.000Z

Against Object Pools

Do not use object pools in your library

Instead expose an interface for applications to implement their own object pools, such as:

interface Lender<T>
{
    T borrow();
    return(T obj);
}

Why? By definition, an object pool is a leaky abstraction. Quite literally, an object pool holds onto memory once it has allocated it (usually). This means users of your library will need to know about your library's object pools when chasing down a memory leak. However, that is not to say that object pools are bad, they can play a crucial role in reducing allocation times, and help with garbage collection overhead. But whether this optimization is worth the trade-off can only be known at the application level.

November 8th, 2025 Log

2025-11-08T00:59:40.000Z

November 8th, 2025

If it can't be automated, then it's not a quality control process, it's just somebody's opinion of what quality is.

Lenovo Slim 7 Pro-X Troubleshooting

2025-12-09T04:17:29.000Z

Lenovo Slim 7 Pro-X Troubleshooting

USB-C Ports Not Recognizing Devices

If the USB-C ports are not recognizing devices — only accepting power delivery, or nothing at all — then try turning the device off, holding the power button for at least 30 seconds (you should see a power cycle on the screen), and trying again.

My Ideal C#-Like Language

2025-12-22T13:43:47.000Z

My Ideal C#-Like Language

Some of these ideas could live with the current language, some would be drastic changes.

An `on` keyword for use after an `await` statement

To make it trivial to switch your synchronization context, an on keyword. Usage:

var updatedValue = await service.GetValue() on UiSynchronizationContext;

I first had this idea in 2022 so I've been on this one for a while.

Easy Implementation of Delegation

If you've been doing this programming thing for a while, you've likely come across the idea of composition over inheritance, that is, prefer delegating implementation to another type instead of inheriting it from a sub-type. Kotlin provides this capability with the by keyword, which seems fine to me. In C#:

interface IAccess
{
    Task<Value> GetValue();

    Task SetValue(Value value);
}

class NetworkAccess(HttpClient httpClient) : IAccess
{
    public Task<Value> GetValue()
    {
        var response = await httpClient.GetJson<Value>();
        return response;
    }

    public Task SetValue(Value value)
    {
        var response = await httpClient.PostJson(value);
    }
}

class CachedAccess(ICache cache, IAccess innerAccess) : IAccess by innerAccess
{
    public Task<Value> GetValue()
    {
        var response = await innerAccess.GetValue();
        cache.Set(key, response);
        return response;
    }

    // SetValue is automatically delegated to innerAccess...
}

Even better would be if we could have automatic decoration. This is a tougher one, how do we handle the infinite number of method combinations? Maybe visitors are a way?

Public Methods Async By Default

In the spirit of more extensive language additions, all public methods should be async by default. A developer should always assume that public methods don't complete immediately. A developer has to instead declare a method sync to state that the method executes immediately. Example:

interface IAccess {
    Value GetValue();
    sync Value GetValueImmediately();
}

var value = await access.GetValue();
var value = access.GetValueImmediately();

What I like about this idea is that method "coloring" works in reverse: the writer of a method has to instead say "this method executes immediately with no I/O access, no computations on another thread", since in the real world, all operations execute asynchronously. One consequence of this idea is that the Task type is hidden, and I do not like hiding "magic" too much, so this definitely has its flaws. Maybe the underlying Task/Promise could be exposed via reflection?

Public Properties Observable By Default

This is another thing that Kotlin/Jetpack Compose sort of has with Mutable State and snapshotFlow, but since it's not a default, you have to kind of guess whether a property is observable or not. In my new language I propose that properties are observable by default. The properties wouldn't need be an IObservable and take on all the baggage of that type, they could just implement IAsyncEnumerable. Example:

class Person {
    public string Name { get; set; }
}

var person = new Person();

var updateNameTask = Task.Run(() => {
    person.Name = "Bob";
    person.Name = "David";
});

await foreach (var name in person.Name)
{
    // Prints "Name: Bob" and then "Name: David"
    Console.WriteLine($"Name: {name}");
}

await updateNameTask;

But you should also just be able to read the current value (see the Interaction State primitive), so you should also be to just call it like a normal property:

class Person {
    public string Name { get; set; } = "John";
}

var person = new Person();
// Prints "John"
Console.WriteLine($"Name: {person.Name}");

Easy Delegation with a C# Source Generators Library

2026-01-21T14:09:48.000Z

Easy Delegation with a C# Source Generators Library

In my last post I posted a wish list for C# that would make program construction easier. One of these was easy implementation of delegation, or in other words, Composition over Inheritance; that is the ability to automagically do this:

interface IAccess
{
    Task<Value> GetValue();

    Task SetValue(Value value);
}

class NetworkAccess(HttpClient httpClient) : IAccess
{
    public async Task<Value> GetValue()
    {
        var response = await httpClient.GetJson<Value>();
        return response;
    }

    public async Task SetValue(Value value)
    {
        var response = await httpClient.PostJson(value);
    }
}

class CachedAccess(ICache cache, IAccess innerAccess) : IAccess
{
    public async Task<Value> GetValue()
    {
        var response = await innerAccess.GetValue();
        await cache.SetValue(response);
        return response;
    }

    public Task SetValue(Value value)
    {
        return inner.SetValue();
    }
}

Well, after I got over the flu this Christmas, I began looking in anger at how to build source generators for C#, with the hope that I could make something like this reality. Using Decorator Generator as a base (which was very close to what I wanted - but I wanted less configuration), I created TypeAdoption, which auto-wires up inner implementations using an [Adopt] attribute. So taking the above example, you can do this:

interface IAccess
{
    Task<Value> GetValue();

    Task SetValue(Value value);
}

class NetworkAccess(HttpClient httpClient) : IAccess
{
    public async Task<Value> GetValue()
    {
        var response = await httpClient.GetJson<Value>();
        return response;
    }

    public async Task SetValue(Value value)
    {
        var response = await httpClient.PostJson(value);
    }
}

// The class needs to be partial
partial class CachedAccess(ICache cache, IAccess innerAccess)
{
    [Adopt]
    private readonly IAccess _inner = innerAccess;

    public async Task<Value> GetValue()
    {
        var response = await _inner.GetValue();
        await cache.SetValue(response);
        return response;
    }
}

This will generate this implementation of IAccess:

partial class CachedAccess : IAccess
{
    public Task SetValue(Value value)
    {
        return _inner.SetValue();
    }
}

Note that GetValue has no auto-generated implementation, since it was implemented in the actual class. This can also be useful for choosing between multiple implementations. For example, say there is another interface that has SetValue with the same signature, and both are adopted, then you'll now have to determine how SetValue works:

interface ICache
{
    public bool IsCached();

    public Value Value { get; }

    public Task SetValue(Value value);
}

partial class CachedAccess(ICache cache, IAccess innerAccess)
{
    [Adopt]
    private readonly ICache _cache = cache;

    [Adopt]
    private readonly IAccess _inner = innerAccess;

    public async Task<Value> GetValue()
    {
        // ICache memebers now available as first-class members of the class.
        if (IsCached())
            return Value;

        var response = await _inner.GetValue();
        // Still just want to go directly to cache for this usage of SetValue()
        await _cache.SetValue(key, response);
        return response;
    }

    public async Task SetValue(Value value)
    {
        // Set both inner values - set the network access first, once that succeeds, cache the value.
        await _inner.SetValue(value);
        await _cache.SetValue(value);
    }
}

Using these contrived examples, one can imagine how it would extend to interfaces with many members; perhaps you are using Refit to implement an extensive API, and a few methods need manual intervention: manually implement those methods and delegate the remaining members to the Refit implementation!

Again, the library is called TypeAdoption, and it's already available on NuGet.

March 8th, 2026 Log

2026-03-08T18:59:40.000Z

March 30th, 2026

Combining Handheld and TV views

In my eternal "wood-carving" project, project blue, I am now attempting to whittle my two root view application (one for TV and one for handhelds) down into one view: the view will automatically assume the split-screen "Browser"/"Now Playing" view when the canvas is wider than it is tall; otherwise, it will still be split, but the Browser and the Now Playing view will be two pages that you swipe between. I'm hopeful that this brings the entire design into one single design that is easier to maintain and use. My plan so far.

March 8th, 2026

When Cory Doctorow speaks of AI, he usually uses a "centaur" metaphor, split into two separate concepts: the "centaur", where the human is assisted by the machine, and the "reverse centaur", where the human has to help the machine. The "centaur" is preferable; a machine helping us do our jobs is the entire point of these things.

Code review is one such case where a language model is a useful tool that assists the human instead of demanding the human help it. Deepseek r1:14b hits a sweet spot for me ― useful feedback that runs quickly on a local GPU with 12GB of ram. I've also found that if the changes are so large that it starts spitting out nonsense, then that probably means that the changes in the commit are too large in the first place!

Keep this quote in your back-pocket

Programs must be written for people to read, and only incidentally for machines to execute.

Harold Abelson, Structure and Interpretation of Computer Programs

April 3rd, 2026 Log

2026-04-03T15:22:23.000Z

April 3rd, 2026

New Picture of Home

Artemis II is already sending back beautiful images of home. When seeing this, although the picture is a much larger of our Earth than the "pale blue dot" seen from Saturn, I'm reminded of Carl Sagan's essay on Earth:

Look again at that dot. That's here. That's home. That's us. On it everyone you love, everyone you know, everyone you ever heard of, every human being who ever was, lived out their lives. The aggregate of our joy and suffering, thousands of confident religions, ideologies, and economic doctrines, every hunter and forager, every hero and coward, every creator and destroyer of civilization, every king and peasant, every young couple in love, every mother and father, hopeful child, inventor and explorer, every teacher of morals, every corrupt politician, every "superstar," every "supreme leader," every saint and sinner in the history of our species lived there--on a mote of dust suspended in a sunbeam.

The Earth is a very small stage in a vast cosmic arena. Think of the rivers of blood spilled by all those generals and emperors so that, in glory and triumph, they could become the momentary masters of a fraction of a dot. Think of the endless cruelties visited by the inhabitants of one corner of this pixel on the scarcely distinguishable inhabitants of some other corner, how frequent their misunderstandings, how eager they are to kill one another, how fervent their hatreds.

Our posturings, our imagined self-importance, the delusion that we have some privileged position in the Universe, are challenged by this point of pale light. Our planet is a lonely speck in the great enveloping cosmic dark. In our obscurity, in all this vastness, there is no hint that help will come from elsewhere to save us from ourselves.

The Earth is the only world known so far to harbor life. There is nowhere else, at least in the near future, to which our species could migrate. Visit, yes. Settle, not yet. Like it or not, for the moment the Earth is where we make our stand.

It has been said that astronomy is a humbling and character-building experience. There is perhaps no better demonstration of the folly of human conceits than this distant image of our tiny world. To me, it underscores our responsibility to deal more kindly with one another, and to preserve and cherish the pale blue dot, the only home we've ever known.

— Carl Sagan, Pale Blue Dot, 1994

Source: Hello, World - Nasa

Events as state or events as notifications?

Much less interestingly, I came across a post on LinkedIn that perfectly crystallizes a difference I've been struggling to define between event sources and event busses: events as state vs. events as notifications https://www.linkedin.com/posts/dcomartin_the-term-event-driven-architecture-has-activity-7444866038204125184-QJ5J

David Vedvick (Notes Feed)

Double the taskbar size... . necessary?

Double the taskbar size... . necessary?

Exciting Stuff

Exciting Stuff

Space Shuttle Launch

Space Shuttle Launch

Windows 7 RTM Coming Up

Windows 7 RTM Coming Up

Firefox Useability Enhancements

Firefox Useability Enhancements

Firefox "Windows 7 Remix" theme:

Personal Menu

Speed Dial

Tabs Open Relative

A tip

The Final Look:

Ordering a Computer on DeVed Computers

Ordering a Computer on DeVed Computers

Step 1: Pick needs that reflect what you want to do with this computer

Step 2: Enter a Budget for your PC

Step 3: Buy a PC that's already been ordered from DeVed Computers or Create your Own

Step 4: Select a case

Step 5-10(ish): Configuration

Step 11: Finalizing your order

Step 12: Link your order to a username

Last Step: Add your computer to the PayPal Cart

The Last Last Step:

Computer stickers/Case Badges

Computer stickers/Case Badges

Just did Java, on to C#

Just did Java, on to C#

Starting up the development blog

Starting up the development blog

A guide to initialization logic

A guide to initialization logic

Neat story on some of the lost disciplines of programming

Neat story on some of the lost disciplines of programming

jQuery UI sort on hidden table rows

jQuery UI sort on hidden table rows

Moving to CakePHP

Moving to CakePHP

SharpXML

SharpXML

Expanding or changing the business...

Expanding or changing the business...

New version of J. River Media Center Windows 7 Integration plug-in released

New version of J. River Media Center Windows 7 Integration plug-in released

Version 0.9.2 of J. River Media Center Plug-in

Version 0.9.2 of J. River Media Center Plug-in

Version 0.9.3 of J. River Windows 7 Integration Media Center Plug-in

Version 0.9.3 of J. River Windows 7 Integration Media Center Plug-in

Oracle 10G and Parentheses

Oracle 10G and Parentheses

Music Streamer for J. River Media Center on the way

Music Streamer for J. River Media Center on the way

A eulogy for a man I didn't ever know...

A eulogy for a man I didn't ever know...

NearlyFreeSpeech.net

NearlyFreeSpeech.net

The new deliciouspc.com (the site formerly known as DevedComputers)

The new deliciouspc.com (the site formerly known as DevedComputers)

Android Media Streamer App Progress

Android Media Streamer App Progress

"JR Media/Music Streamer" screenshots...

"JR Media/Music Streamer" screenshots...

"Project Blue Water" - formerly known as "Media Streamer" progress

"Project Blue Water" - formerly known as "Media Streamer" progress

My (slightly (un)qualified) thoughts on Windows

My (slightly (un)qualified) thoughts on Windows

Version 0.9.4 of Windows 7/8 J. River Integration Media Center Plug-in

Version 0.9.4 of Windows 7/8 J. River Integration Media Center Plug-in

Windows 8.1 Upgrade - potential hard drive killer?

Windows 8.1 Upgrade - potential hard drive killer?

The Promise of Google Voice

The Promise of Google Voice

Latest Project Blue Water Updates

Latest Project Blue Water Updates

An ideal SPA

An ideal SPA