DEV Community: Alex Sarafian

Upgrade from Pester v4 to v5

Alex Sarafian — Sat, 26 Jun 2021 12:54:58 +0000

Background

Recently somebody submitted a pull request in my SemVerPS which failed with the Appveyor's CI pipeline. I've not been hands on for a while and it took me some time to figure out that the tests were failing and why. It turns out that there has been a new version (v5) of Pester which broke compatibility compared with the previous version (v4). Soon, it became clear to me that that I would have to make significant changes which meant that I had to work on my PowerShellTemplate repository, where advanced Pester test cases are also covered.

All the changes are available in this pull request and in the following sections I'll focus on the major adaptations required. To help showcase the requires changes, I'll provide the relevant extracts from the V4 and V5. Keep in mind that the extracts are relevant to the [PowerShelltTemplate] repository.

Invoke-Pester adaptations

The Invoke-Pester cmdlet has many changes when used in an "advanced" mode. Basic execution still works but when the cmdlet is integrated in a CI pipeline like I do in the [PowerShelltTemplate] repository with the CI\Invoke-Pester.ps1, then you probably need to use some of the advanced functionality. The main difference is that with version 5, the cmdlet is driven by a configuration variable that is initialized by the New-PesterConfiguration cmdlet. The cmdlet's documentation page provides an explanation for all options but for some it is not clear what they really do.

V4 extracts

$splat=@{
    Script=$srcPath
    PassThru=$true
    OutputFormat="NUnitXml"
    OutputFile=$outputFile
    ExcludeTag=$ExcludeTag
    Tag=$Tag
}

# Activate code coverage
if($CodeCoverage)
{
    $codeCoveragePath=$outputFile.Replace(".xml",".codecoverage.xml")
    $splat+=@{
        CodeCoverage=Get-ChildItem -Path $srcPath -Exclude @("*.Tests.ps1","*.NotReady.ps1","Src\Tests\**") -Filter "*.ps1" -Recurse|Select-Object -ExpandProperty FullName
        CodeCoverageOutputFile=$codeCoveragePath        
    }
}

$pesterResult=Invoke-Pester @splat

V5 extracts

# https://pester-docs.netlify.app/docs/commands/New-PesterConfiguration
$pesterConfiguration=New-PesterConfiguration
$pesterConfiguration.Run.Path=$srcPath
$pesterConfiguration.Run.PassThru=$true
$pesterConfiguration.Run.Path=$srcPath
$pesterConfiguration.Filter.Tag=$Tag
$pesterConfiguration.Filter.ExcludeTag=$ExcludeTag

$pesterConfiguration.TestResult.Enabled=$true
$pesterConfiguration.TestResult.OutputFormat="NUnitXml"
$pesterConfiguration.TestResult.OutputPath=$outputFile

$pesterConfiguration.Output.Verbosity="Detailed"
# If you want full log uncomment
#$pesterConfiguration.Output.Verbosity="Diagnostic"

# Activate code coverage
if($CodeCoverage)
{
    $pesterConfiguration.CodeCoverage.Enabled=$true
#    $pesterConfiguration.CodeCoverage.OutputFormat="JaCoCo"
    $pesterConfiguration.CodeCoverage.OutputPath=$outputFile.Replace(".xml",".codecoverage.xml")
}

$pesterResult=Invoke-Pester -Configuration $pesterConfiguration

Notice that most features were moved into the configuration variable but there are also some new welcoming options especially with regards to diagnostics. I chose Detailed for $pesterConfiguration.Output.Verbosity because I found it to be the right balance between knowing what Pester is doing and logging. In the same pull request you will also notice that I moved the following block from a global script check to specifically within the AppVeyors block. This is because the new version reacts differently when there are test errors. There are configuration variables for better control and maybe I missed something but I found this to be the easiest adaptation. You need to first upload the test results to AppVeyor and therefore you can't instruct Pester to exit the script from within Pester. This is also documented in AppVeyor's [running test] page.

if ($pesterResult.FailedCount -gt 0) { 
     throw "$($pesterResult.FailedCount) tests failed."
}

Test file adaptations

Big differences in the test files *Tests.ps1 are:

Everything has to run in a block defined in a Pester function like BeforeAll or BeforeEach. They also adjusted the New-Fixture cmdlet.
All Should expressions need to use - with the Be, Throw etc assertions.
Throw statements used to match text without wildcards. Now they are matched by comparison unless wildcards * are provided similar to -Like statements.

V4 extracts

$here = Split-Path -Parent $MyInvocation.MyCommand.Path
$sut = (Split-Path -Leaf $MyInvocation.MyCommand.Path) -replace '\.Tests\.', '.'
. "$here\$sut"

It "Just invoke" {
        Get-M1|Should BeExactly "M1"
}

It "Error" {
        {throw "error"}|Should Throw "error"
}

V5 extracts

BeforeAll {
    . $PSCommandPath.Replace('.Tests.ps1', '.ps1')
}

It "Just invoke" {
        Get-M1|Should BeExactly "M1"
}

It "Error" {
        {throw "error"}|Should -Throw "*error*"
}

Mocking and InModuleScope adaptations

The hardest part was with mocking modules, leveraging common functionality (like a random generator) and doing all this within an InModuleScope block. In V4 there were a lot of gaps but the implementations were less verbose. The new strictness is welcome but there is now more code required especially. This is because the InModuleScope is really a new scope (hence the name) and won't recognize local variables from other blocks, like e.g. a random string.

To better understand the following differences, I need to first explain that in my code, I use a common function to generate random strings and numbers. I do this, to make sure that all unit tests work with clean values and nothing is overlooked. This is important, because the scripting nature of PowerShell allows for left over variables from within the same block or a previous execution which sometimes don't raise errors. My random generator is implemented in the Get-RandomValue cmdlet and is found in Src/Tests/Cmdlets-Helpers/Get-RandomValue.ps1.

The Get-RandomValue.ps1 got also adjusted because now it is not necessary to define it as global function. In the past the function would be declared as function global:Get-RandomValue but now it can be a normal one and be declared as function Get-RandomValue.

The goal is to test and mock the private cmdlet Get-M1Private which is called by the public Get-M1 cmdlet. Notice that when mocking the Get-M1Private, I always use a fresh random string using Get-RandomValue

V4 file


& $PSScriptRoot\..\..\..\Modules\Import-M1.ps1
# Dot sourcing
. $PSScriptRoot\..\..\Cmdlets-Helpers\Get-RandomValue.ps1

Describe -Tag @("M1","Module","InModuleScope") "InModuleScope M1" {
    InModuleScope M1 {
        It "Get-M1Private" {
            Get-M1Private| Should BeExactly "M1 Private"
        }
        It "Get-M1" {
            Get-M1| Should BeExactly "M1"
        }
    }
}

Describe -Tag @("M1","Module","InModuleScope","MockPrivate") "InModuleScope M1 Mock private" {
    InModuleScope M1 {
        $mockedValue=Get-RandomValue -String
        Mock Get-M1Private {
            $mockedValue
        }
        It "Get-M1Private Mocked" {
            Get-M1Private| Should BeExactly $mockedValue
        }
        It "Get-M1" {
            Get-M1| Should BeExactly $mockedValue
        }
    }
}

Describe -Tag @("M1","Module") "M1" {
    Describe -Tag @("M1","Module") "M1" {
        Get-M1| Should -BeExactly "M1"
    }
}

Remove-Module -Name M1 -Force

A couple of things that require special attention with the V5 adaptations:

The InModuleScope block needs to move inside each It block. This is until version 5.3.0 as mentioned in this issue raised on Pester's gitub repository.
The variable mockedValue which is assigned in the BeforeEach block must now be provided to the InModuleScope block as a function parameter because without the parameter the Get-M1Private| Should -BeExactly $mockedValue will fail because the expected value is actually $null.
As the module M1 is imported inside a BeforeAll block, it must also be removed inside an AfterAll block.

V5 file

BeforeAll {
    & $PSScriptRoot\..\..\..\Modules\Import-M1.ps1
    . $PSScriptRoot\..\..\Cmdlets-Helpers\Get-RandomValue.ps1
}

Describe -Tag @("M1","Module","InModuleScope") "InModuleScope M1" {
    It "Get-M1Private" {
        InModuleScope M1 {
            Get-M1Private| Should -BeExactly "M1 Private"
        }
    }
    It "Get-M1" {
        Get-M1| Should -BeExactly "M1"
    }
}

Describe -Tag @("M1","Module","InModuleScope","MockPrivate") "InModuleScope M1 Mock private" {
    BeforeEach {
        $mockedValue=Get-RandomValue -String
        Mock -ModuleName M1 Get-M1Private {
            $mockedValue
        }
        $inModuleScopeParameters = @{
            mockedValue = $mockedValue
        }

    }
    It "Get-M1Private Mocked" {
        InModuleScope M1 -Parameters $inModuleScopeParameters {
            param($mockedValue)
            Get-M1Private| Should -BeExactly $mockedValue
        }
    }
    It "Get-M1" {
        Get-M1| Should -BeExactly $mockedValue
    }
}

Describe -Tag @("M1","Module") "M1" {
    Describe -Tag @("M1","Module") "M1" {
        Get-M1| Should -BeExactly "M1"
    }
}
AfterAll {
    Remove-Module -Name M1 -Force
}

Final thoughts

What I didn't do is adapt all Describe and It blocks and declare the name properly using the -Name parameter. I expect that in the next version I'll get a similar error with the This whole Legacy-parameter set is deprecated that `Invoke-Pester throws when not using the configuration variable with legacy options.

Overall, I feel that Pester has improved and that this was a step to the right direction but it needs getting used to it. From my experience, the InModuleScope adaptations were the hardest ones to figure out. Some extra quirks had to be addressed in my other repositories MarkdownPS and SemVerPS.

If you are an owner of a PowerShell module with full unit tests and code coverage, then I hope I hope you found this post useful.

PlantUML tips and tricks

Alex Sarafian — Fri, 12 Mar 2021 16:54:17 +0000

I love PlantUML. It has it's limitations but if the size and the complexity of the diagrams can be contained, then it offers great benefits. The fact that the format is in text is so powerful in software engineering because it can be attached to any process with change management over source control. Also, it is great for Confluence when the PlantUML Diagrams for Confluence add-on is enabled.

With this post I want to share some tips and tricks from my experience using it.

Layout orientation in component diagram

When using the component diagram, often the layout seems to have a mind of it's own. You can try to provide some guidelines to the rendering component by adding directions in the arrows (e.g. -l->) but when that doesn't work, I try to achieve an optimal layout by reorganizing the appearance of the components, especially when they are nested with e.g. package. It is a bit strange, but order in rendering seems to follow a reverse order of appearance in the script.

Multiple and options flows in a component diagram

Sometimes, I want to have multiple flows within a component diagram. In this case and depending on the case, I use color coding with each arrow (e.g. A -> B #Green : text) and possibly add a legend at the end

@startuml

package "Some Group" {
  HTTP - [First Component]
  [Another Component]
}

node "Other Groups" {
  FTP - [Second Component]
  [First Component] --> FTP
}

cloud {
  [Example 1]
}


database "MySql" {
  folder "This is my folder" {
    [Folder 3]
  }
  frame "Foo" {
    [Frame 4]
  }
}

[Another Component] --> [Example 1] #Blue
[Example 1] --> [Folder 3] #Blue
[Folder 3] --> [Frame 4] #Blue


legend
    | Color | Flow |
    |<#Red>|  Flow 1 |
    |<#Blue>|  Flow 2 |
endlegend

@enduml

When sequence is important then I use a numbering scheme like this

Flow 1
- 1.1 action
- 1.2 action
Flow 2
- 2.1 action
- 2.2 action

Autonumber events in sequence diagram

One of the best features of sequence diagrams is the autonumber feature which will add a number before the text of each event as explained in the documentation

@startuml

autonumber
Bob -> Alice : Authentication Request
Bob <- Alice : Authentication Response

@enduml

Autonumbers can be formatted. In the following example the number is 2-digit padded and highlighted.

@startuml

autonumber "<B>[00]"
Bob -> Alice : Authentication Request
Bob <- Alice : Authentication Response

@enduml

Mode	Diagram
simple
formatted

I prefer the autonumber "<B>[00]" the most because I've never had to exceed 99 events in a diagram. Besides, when my diagrams become big, they are usuall split by a deviders and seperators (==) and for each I restart the the numbering in the sequence.

Text alignment in sequence diagram

In the above example, the lines can be brought closer together to make the diagram more dense with this skin parameter skinparam responseMessageBelowArrow true.

@startuml

skinparam responseMessageBelowArrow true

autonumber "<B>[00]"
Bob -> Alice : Authentication Request
Bob <- Alice : Authentication Response

@enduml

Mode	Diagram
default
responseMessageBelowArrow

Semi transparent group backgrounds in sequence diagrams

I like to group my participants in boxes and color code them because when the sequence is long, you can quickly identify the scope of the vertical you are looking at even when the participants are out of view. Problem is that every one of the Grouping message features (group,alt/else,opt,loop,par,break,critical and group) are rendered by default with a white solid background which hides the color of the box. This is annoying when the group overlaps many verticals and becomes one massive big white background. A solution for this is not easy. You could use the #Transparent but then the entire group's background becomes transparent and when big the context is lost.

This was not easy to find, but PlantUML skinning supports alpha channel and the background can be set through the skin. Skin Parameters are not documented extensively and I was able to find the proper one SequenceGroupBodyBackgroundColor through this page. After some experimentation, I've decided to use white with some tranparency using this value #FFFFFF90.

@startuml

skinparam SequenceGroupBodyBackgroundColor #FFFFFF90

box "Internal Service" #LightBlue
    participant Bob
    participant Alice
end box

box "Other" #LightGreen
    participant Other
end box

group group
    Bob -> Alice : hello
    Alice -> Other : hello
end

@enduml

Mode	Diagram
default
transparent
semi-transparent

Solve cut off issue

When using the default PlantUML server to render the diagrams in png, often the diagrams are cut off because PlantUML limits image width and height to 4096. This issue is discussed on github issue and the solution is to either use command line parameters or use the skinparam dpi X parameter. When using the VSCode PlantUML add-on with the default server, this is the only solution as current the add-on doesn't support command line parameters. Unfortunately, the X for the dpi needs to be found by experimentation to make sure the diagram fits. As the diagram grows horizontally, the parameter needs to be adjusted accordingly.

Help with skinning

PlantUML supports many different colors by name but it is kind of a maze. Use the colors command to render a picture with all colors

@startuml

colors

@enduml

Unfortunately the Skin Parameters are not very well documented and the best comprehensive list is in the All Skin Parameters page.

Enhance PowerShell tracing and logging for the console and transcriptions

Alex Sarafian — Sun, 12 Apr 2020 11:01:19 +0000

Background

XWrite was originally created for PowerShell 4 but it works flawlessly with the latest and greatest of PowerShell (7.0.0). It is a 100% script-powered module and explicit effort was made to keep it as less intrusive as possible to PowerShell given the sensitive nature of the affected cmdlets.

The module was created because back then I was building a very complicated CI/CD pipeline for deploying SDL Knowledge Center on Amazon Web Services. As part of this effort and as I matured into the technology I realized some of the shortcomings of PowerShell and thought of some enhancements I would like for myself.

PowerShell's default tracing to the console or transcription files is lacking. To give an example, I would love to see, which cmdlet or script wrote something as debug, verbose, information, warning or even an error. The script developer needs to always add this information in the body of the output-ed entry which makes tracing annoying for the developer and the code-base dirty.
PowerShell is missing a seamless redirection of the progress into the console and transcription. Because of this, the developer of the script needs to code both lines for nice interactive user experience but also a solid trace when the script executes in non-interactive mode. I also don't like the rendering of the Write-Progress's output which often interferes with the console and is different per host (e.g. PowerShell, PowerShell ISE, PWSH, VSCode etc). I like the concept though and I would like to have the option to redirect it to the console.
PowerShell is missing a simple and fast way to enable full tracing to the console. I don't want to modify multiple preference variables e.g. $DebugPreference without autocomplete. There has to be something simpler and faster.

For these reasons and to improve my experience with PowerShell as a developer and the transcription analysis, I had developed back then (2007) the XWrite module. It turns out that it works so well, that I started using it with every PowerShell session by loading the module through my profile.

Here is a glimpse of the normal and enhanced outputs

PowerShell normal output	PowerShell output with XWrite enabled

XWrite features

The module can:

Enable full tracing for all preference variables and rollback to the original settings.
Enhance the output of the following core (Microsoft.PowerShell.Utility) cmdlets:
- Write-Host
- Write-Debug
- Write-Verbose
- Write-Information
- Write-Warning
Add inline additional output for the native Write-Progress cmdlet using:
- Write-Host
- Write-Debug
- Write-Verbose
- Write-Information
Seamless support with PowerShell transcriptions.

The output of each of the Write-* cmdlets can be enhanced with the following extra information:

The Source that is the source script or module name that executed the Write- cmdlet.
The Caller that is the name of the script or module that executed the Write- cmdlet.
The Date that is the date part of the current date.
The Time that is the time part of the current date.

The above functionality is enabled or disabled by use of the following groups of cmdlets:

To enable/disable different levels of preference variables:
- Set-XGlobalTrace
- Undo-XGlobalTrace
To enable/disable the enhanced output
- Enable-XWrite
- Disable-XWrite
To enable/disable progress output redirection
- Enable-XWriteProgress
- Disable-XWriteProgress

Setting up for the demo

To demonstrate let's first create a sample function Test-MyXWrite that just writes the preference value per Debug,Verbose,Information and Warning using the respected cmdlets Write-Debug, Write-Verbose,Write-Information and Write-Warning. The same is written to the host using the Write-Host cmdlet.

# Sample function that uses Write-* commands without any changes
function Test-MyXWrite
{
    param(
    )

    $message=@(
        "DebugPreference=$DebugPreference"
        "VerbosePreference=$VerbosePreference"
        "InformationPreference=$InformationPreference"
        "WarningPreference=$WarningPreference"
    )

    $message|ForEach-Object {
        Write-Host $_
    }

    Write-Debug "DebugPreference=$DebugPreference"
    Write-Verbose "VerbosePreference=$VerbosePreference"
    Write-Information "InformationPreference=$InformationPreference"
    Write-Warning "WarningPreference=$WarningPreference"
}

Then we first enable all preference variables using Set-XGlobalTrace, invoke the Test-MyXWrite and undo the changes of Set-XGlobalTrace using the Undo-XGlobalTrace.

# Enable full trace 
Set-XGlobalTrace -ForAll

# Invoke test function to execute the Write-* commands
Test-MyXWrite

# Disable full trace. Rollback to original settings
Undo-XGlobalTrace

This is how it looks:

Demo of XWrite enhanced output

To showcase the enhanced output, we just need to enable it using Enable-XWrite and the rest of the demo is the same as before.

# Enable XWrite default output enhancement
Enable-XWrite -ForAll

# Enable full trace 
Set-XGlobalTrace -ForAll

# Invoke test function to execute the Write-* commands
Test-MyXWrite

# Disable full trace. Rollback to original settings
Undo-XGlobalTrace

This is how it looks:

Notice that the name of the invoker, that is Test-MyXWrite shows up as well.

Demo of XWrite advanced enhanced output

The enhanced output could be configured to output more information with additional tokens such as the invoker's type and the timestamp using additional parameters of Enable-XWrite.

# Enable XWrite advanced output enhancement
Enable-XWrite -ForAll -Source -Date -Time

# Enable full trace 
Set-XGlobalTrace -ForAll

# Invoke test function to execute the Write-* commands
Test-MyXWrite

# Disable full trace. Rollback to original settings
Undo-XGlobalTrace

This is how it looks:

Notice that the source Function and a timestamp are added extra to the name `Test-MyXWrite.

Formatting of advanced output

The module will add a prefix to the output with the following logic:

The invoker's name Test-MyXWrite is always present.
When the -Source parameter is used then the source of the invoker is added. For example
- Function when the invocation originates from a function declared in-script as above.
- ModuleName when the invocation originates from a function that is part of a module.
- FileName when the invocation originates from a script file.
- <SCRIPT> when the invocation originates from a script block.
When -Date or -Time is used, then their respected values are added.
When the -Separator parameter is used, then the default : separator is adapted.
When the -Format parameter is specified then the provided custom format is used. The valid tokens are:
- %source%
- %caller%
- %date%
- %time%.

This is a consolidated matrix"

Token in `-Format` parameter	Parameter	Example value	Remarks
`%source%`	`-Source`	`Function`	The invoker's type
`%caller%`	No parameter. Always active	Test-MyXWrite	The invoker's name
`%date%`	`-Date`	20170804	the date stamp formatted as `yyyyMMdd`
`%time%`	`-Time`	10:57:27.858	the time stamp formatted as `hh:mm:ss.fff`

Considerations

The module works by placing a global implementation overwrite of the respected cmdlet over the core one from the Microsoft.PowerShell.Utility namespace. This effectively overwrites the default behavior of each Write-* cmdlet. With this understanding, the following need to be always considered:

When the invocation is like Microsoft.PowerShell.Utility/Write-Host then the global overwrite is bypassed.
Binary modules, target through compiling the namespaced Write-* functions and because of that XWrite will not enhance their output.

Impact on PowerShell's core functionality

The impact is minimum because XWrite utilizes the above considerations and lets PowerShell's default Write-* functionality do the heavy lifting. This means that the module doesn't interfere with PowerShell and just modifies the payload of the used parameters.

Best practices

Here are some best practices I've picked up over the years:

Use Enable-XWrite and Enable-XWriteProgress before Set-XGlobalTrace because they write to DEBUG the body of the overwrites and that can clutter the output.
If you want to sneak pick in the implementation of each of the overwriting functions then use Set-XGlobalTrace first and then invoke Enable-XWrite and Enable-XWriteProgress
You don't have to do anything about the transcription output. This is managed by PowerShell by redirecting the output to a file. Since XWrite used the PowerShell's own Write-* functionality it just works.
Try to invoke the Enable-XWrite and Enable-XWriteProgress as early as possible in your session, so any transcriptions are enhanced from the beginning.
- For your interactive sessions, just add in your profile script.
- For non-interactive flows, this could be part of the pipeline.

Originally posted here

Add semantic versioning capabilities to PowerShell

Alex Sarafian — Tue, 07 Apr 2020 16:08:28 +0000

The SemVerPS PowerShell module offers the ability to work with Semantic Version utilizing the .net implementation from Max Hauser's SemVer repository. With this module, it is possible to:

Work with Semantic Version as typed object leveraging or comparison operators
Enhance object with a NoteProperty that contains a Semantic Version.
Filter and/or test above enhanced list of objects.
- This could be very useful if for example a list of items is retrieved where part of the name is a semantic version and we want to filter the list.

Basic usage with ConvertTo-SemVer

Use the ConvertTo-SemVer to convert strings to semantic version objects. For example:

ConvertTo-SemVer -Version "1.0.0"

Major      : 1
Minor      : 0
Patch      : 0
Prerelease : 
Build      :

ConvertTo-SemVer -Version "1.0.1-alpha+1" -Strict

Major      : 1
Minor      : 0
Patch      : 1
Prerelease : alpha
Build      : 1

Use the Test-SemVer to test if a string or a semantic version is stable or prerelease. For example:

Test-SemVer -InputObject "1.0.0"
#True

Test-SemVer -InputObject "1.0.0" -Stable
#True

Test-SemVer -InputObject "1.0.0-alpha+1" -PreRelease alpha
#True

Add semantic versioning member to existing objects

Often there is a need to attach a semantic version notation to an object or a list of objects. Use the Add-SemVerMember to add a member where the semantic version value is derived either from an expression or a script block. By default the semantic version is add to a property named SemVer but this can be changed by defining the Property parameter. For example:

[pscustomobject]@{Name="example-1.0.0"}|Add-SemVerMember -Expression 'Name.Replace("example-","")' -PassThru
[pscustomobject]@{Name="example-1.0.0"}|Add-SemVerMember -ScriptBlock {$_.Name.Replace("example-","")} -PassThru -Name "AnotherProperty"

Name          SemVer
----          ------
example-1.0.0 1.0.0


Name          AnotherProperty
----          ---------------
example-1.0.0 1.0.0

As an extension of the Test-SemVer, use the Limit-SemVer to filter objects based on semantic version conditions. Each object can be in the form of a string, or a semantic version instance or an object that has been enhanced with Add-SemVerMember. For example:

$versions=@(
    "1.0.0"
    "1.0.0-alpha+1"
)
$versions|Limit-SemVer -Stable
$versions|Limit-SemVer -Prerelease alpha

1.0.0

1.0.0-alpha+1

$objectsWithVersions=@(
    "example-1.0.0"
    "example-1.0.0-alpha+1"
)|Foreach-Object {
    [pscustomobject]@{Name=$_}| Add-SemVerMember -Expression 'Name.Replace("example-","")' -PassThru  
}
$objectsWithVersions
$objectsWithVersions|Limit-SemVer -Stable
$objectsWithVersions|Limit-SemVer -Prerelease alpha

Name          SemVer
----          ------
example-1.0.0 1.0.0

Name                  SemVer
----                  ------
example-1.0.0-alpha+1 1.0.0-alpha+1

Copied from my personal blog post

Render a computer badge with name and state in markdown with PowerShell using MarkdownPS

Alex Sarafian — Mon, 06 Apr 2020 20:03:17 +0000

Originally posted here

Using MarkdownPS PowerShell module this is a simple cmdlet that

Tests the state of the computer using PowerShell's Test-Connection cmdlet
Depending on the outcome it generates a badge in markdown with red or green state.

function New-ComputerBadge {
    param (
        [Parameter(Mandatory=$true)]
        [string]
        $Computer
    )
    try
    {
        if(Test-Connection $Computer -Quiet)
        {
            $color="green"
            $status="Live"
        }
        else
        {
            $color="red"
            $status="Not Live"
        }
        New-MDImage -Subject $Computer -Status $status -Color $color
    }
    catch
    {
        Write-Error $_
        New-MDImage -Subject "Badge" -Status "Error" -Color red
    }
}

Example

New-ComputerBadge -Computer "EXAMPLE"

renders the following markdown

![](https://img.shields.io/badge/EXAMPLE-Live-green.svg)
![](https://img.shields.io/badge/EXAMPLE-Not%20Live-red.svg)

Render badges with PowerShell MarkdownPS and shields.io

Alex Sarafian — Mon, 06 Apr 2020 20:03:02 +0000

Originally poste here

In my previous post Generate markdown from PowerShell with MarkdownPS I explained the basic cmdlets of the PowerShell module MarkdownPS.

Shields.io provides many interesting badges out of the box, but there is also an API that can be used to render any badge.

https://img.shields.io/badge/<SUBJECT>-<STATUS>-<COLOR>.svg

The above just renders

On version 1.4 of the MarkdownPS a new parameter set was added to the New-MDImage cmdlet to drive this api.

New-MDImage -Subject "<SUBJECT>" -Status "<STATUS>" -Color red

Renders

![](https://img.shields.io/badge/%3CSUBJECT%3E-%3CSTATUS%3E-red.svg)

The produced url in the image is url encoded. The parameter -Color accepts only values that the shields.io API allows.

Color	Badge
brightgreen
green
yellowgreen
brightgreen
yellow
orange
red
lightgrey
blue

To make a badge clickable then use the -Link parameter like this

New-MDImage -Subject "example.com" -Status "OK" -Color green -Link "https://example.com"

Generate markdown from PowerShell with MarkdownPS

Alex Sarafian — Mon, 06 Apr 2020 19:44:44 +0000

Originally posted here

MarkdownPS is a PowerShell module that wraps the markdown syntax into PowerShell cmdlets.

Initially I ran into the PSMarkdown for which ishu3101 had developed a cmdlet that renders a table in markdown syntax. This was very useful and I decided that I needed more functionality provided by cmdlets to render other aspects of markdown. After discussing with ishu3101 I pushed a head and created a module of my own. The New-MDTable cmdlet's code is inspired by the ConvertTo-Markdown by ishu3101 but I enhanced it with column alignment.

This is my first open source projects in GitHub, so I took the opportunity to educate myself a bit about it. The MarkdownPS repository is integrated with visual studio services and I also use Pester to unit test each cmdlet. Overall, it was a good experience while picking up PowerShell knowledge along. Integrating Pester from Visual Studio Services is a bit tricky because VSS runs on PowerShell 4 and the Pester is available with PowerShell v5. The solution is available in code.

Rendering headers

New-MDHeader "Headings"
New-MDHeader "The second largest heading" -Level 2
"The smallest heading"|New-MDHeader  -Level 6

renders

# Headings

## The second largest heading

###### The smallest heading

Headings

The second largest heading

The smallest heading

Paragraphs

$lines=@(
    "Paragraphs are separated by empty lines. Within a paragraph it's possible to have a line break,"
    "simply press <return> for a new line."
)
New-MDParagraph -Lines $lines
$lines=@(
    "For example,"
    "like this."
)
New-MDParagraph -Lines $lines

renders

Paragraphs are separated by empty lines. Within a paragraph it's possible to have a line break,
simply press <return> for a new line.

For example,
like this.

Paragraphs are separated by empty lines. Within a paragraph it's possible to have a line break,
simply press for a new line.

For example,
like this.

Bold, Italic and StrikeThrough

New-MDCharacterStyle -Text "Italic characters" -Style Italic
New-MDCharacterStyle -Text "bold characters" -Style Bold
New-MDCharacterStyle -Text "strikethrough text" -Style StrikeThrough
"All Styles" | New-MDCharacterStyle -Style Bold| New-MDCharacterStyle -Style Italic | New-MDCharacterStyle -Style StrikeThrough

renders

*Italic characters*

**bold characters**

~~strikethrough text~~

~~***All Styles***~~

Italic characters

bold characters

~~strikethrough text~~

~~All Styles~~

Lists

$lines=@(
    "George Washington",
    "John Adams",
    "Thomas Jefferson"
)
New-MDList -Lines $lines -Style Unordered

$lines=@(
    "James Madison",
    "James Monroe",
    "John Quincy Adams"
)
New-MDList -Lines $lines -Style Ordered


New-MDList -Lines "Make my changes" -Style Ordered -NoNewLine
New-MDList -Lines @("Fix bug","Improve formatting") -Level 2 -Style Ordered -NoNewLine
New-MDList -Lines "Make the headings bigger" -Level 3 -Style Unordered -NoNewLine
New-MDList -Lines "Push my commits to GitHub" -Style Ordered -NoNewLine
New-MDList -Lines "Open a pull request" -Style Ordered -NoNewLine
New-MDList -Lines @("Describe my changes","Mention all the members of my team") -Level 2 -Style Ordered -NoNewLine
New-MDList -Lines "Ask for feedback" -Level 3 -Style Unordered

renders

- George Washington
- John Adams
- Thomas Jefferson


1. James Madison
2. James Monroe
3. John Quincy Adams


1. Make my changes

   1. Fix bug
   2. Improve formatting

    - Make the headings bigger

1. Push my commits to GitHub

1. Open a pull request

   1. Describe my changes
   2. Mention all the members of my team

    - Ask for feedback

George Washington

John Adams

Thomas Jefferson

James Madison

James Monroe

John Quincy Adams

Make my changes

Fix bug

Improve formatting
- Make the headings bigger
Push my commits to GitHub

Open a pull request

Describe my changes

Mention all the members of my team
- Ask for feedback

Links

"This is "+(New-MDLink -Text "an example" -Link "http://www.example.com/")+" inline link."
New-MDParagraph

(New-MDLink -Text "This link" -Link "http://www.example.com/" -Title "Title")+" has a title attribute."

renders

This is [an example](http://www.example.com/) inline link.

[This link](http://www.example.com/ "Title") has a title attribute.

This is an example inline link.

This link has a title attribute.

Images

New-MDImage -Source "https://www.powershellgallery.com/Content/Images/Branding/psgallerylogo.svg" -AltText "Alt text"
New-MDParagraph
New-MDImage -Source "https://www.powershellgallery.com/Content/Images/Branding/psgallerylogo.svg" -AltText "Alt text" -Title "Optional title attribute"

renders

![Alt text](https://www.powershellgallery.com/Content/Images/Branding/psgallerylogo.svg)

![Alt text](https://www.powershellgallery.com/Content/Images/Branding/psgallerylogo.svg "Optional title attribute")

Quote

New-MDParagraph -Lines "In the words of Abraham Lincoln:"
$lines=@(
    "Pardon my French"
)
New-MDQuote -Lines $lines

New-MDParagraph -Lines "Multi line quote"
$lines=@(
    "Line 1"
    "Line 2"
)
New-MDQuote -Lines $lines

renders

Multi line quote

> Line 1
>
> Line 2

Multi line quote

Line 1

Line 2

Code fences

"Use "+(New-MDInlineCode -Text "git status") + "to list all new or modified files that haven't yet been committed."

New-MDParagraph -Lines "Some basic Git commands are:" -Style "text"
$lines=@(
    "git status",
    "git add",
    "git commit"
)
New-MDCode -Lines $lines

renders

Use \`git status\`to list all new or modified files that haven't yet been committed.
Some basic Git commands are:



```text
    git status
    git add
    git commit


> Use `git status`to list all new or modified files that haven't yet been committed.
> Some basic Git commands are:
>



```text
    git status
    git add
    git commit

Tables

New-MDHeader "Tables"
New-MDParagraph -Lines "Without aligned columns"
Get-Command -Module MarkdownPS |Select-Object Name,CommandType,Version | New-MDTable
New-MDParagraph -Lines "With aligned columns"
Get-Command -Module MarkdownPS | New-MDTable -Columns ([ordered]@{Name="left";CommandType="center";Version="right"})

renders

Without aligned columns


| Name                 | CommandType          | Version              |
| -------------------- | -------------------- | -------------------- |
| New-MDCharacterStyle | Function             |                      |
| New-MDCode           | Function             |                      |
| New-MDHeader         | Function             |                      |
| New-MDImage          | Function             |                      |
| New-MDInlineCode     | Function             |                      |
| New-MDLink           | Function             |                      |
| New-MDList           | Function             |                      |
| New-MDParagraph      | Function             |                      |
| New-MDQuote          | Function             |                      |
| New-MDTable          | Function             |                      |

With aligned columns


| Name                 | CommandType          | Version              |
| -------------------- |:--------------------:| --------------------:|
| New-MDCharacterStyle | Function             |                      |
| New-MDCode           | Function             |                      |
| New-MDHeader         | Function             |                      |
| New-MDImage          | Function             |                      |
| New-MDInlineCode     | Function             |                      |
| New-MDLink           | Function             |                      |
| New-MDList           | Function             |                      |
| New-MDParagraph      | Function             |                      |
| New-MDQuote          | Function             |                      |
| New-MDTable          | Function             |                      |

Without aligned columns

Name CommandType Version

New-MDCharacterStyle Function

New-MDCode Function

New-MDHeader Function

New-MDImage Function

New-MDInlineCode Function

New-MDLink Function

New-MDList Function

New-MDParagraph Function

New-MDQuote Function

New-MDTable Function

With aligned columns

Name CommandType Version

New-MDCharacterStyle Function

New-MDCode Function

New-MDHeader Function

New-MDImage Function

New-MDInlineCode Function

New-MDLink Function

New-MDList Function

New-MDParagraph Function

New-MDQuote Function

New-MDTable Function

Name	CommandType	Version
New-MDCharacterStyle	Function
New-MDCode	Function
New-MDHeader	Function
New-MDImage	Function
New-MDInlineCode	Function
New-MDLink	Function
New-MDList	Function
New-MDParagraph	Function
New-MDQuote	Function
New-MDTable	Function

Name	CommandType	Version
New-MDCharacterStyle	Function
New-MDCode	Function
New-MDHeader	Function
New-MDImage	Function
New-MDInlineCode	Function
New-MDLink	Function
New-MDList	Function
New-MDParagraph	Function
New-MDQuote	Function
New-MDTable	Function

Creating a private Facebook Messenger chatbot

Alex Sarafian — Sat, 28 Mar 2020 18:13:41 +0000

If you need a bot for your personal home automation, then this post describes how to achieve what is perceived as a private bot on Facebook's Messenger platform.

Not exactly a private bot

With private, I'm referring to bots that are not possible to be found by others or won't interact with others. These sort of bots are meant usually for some personal automation, where the bot act as the delivery entity to you or your family.

On my previous post Creating a private Telegram chatbot, a comment was raised about the "private" nature of Telegram's bots. With private, I'm referring to a bot that though not private can help establish your very own private communication channel. You control who can interact with the bot and who not. If the bot is discoverable, then there is no functionality supported to others and most importantly, your communication is only visible to yourself or others you have invited.

Creating a Facebook page

On Facebook, everything is driven by a page. Organizations will create an organization page but as many do, we can also create own small pages. A page is always required for a Messenger bot to work. The page serves its purpose to establish an entry point of interaction with other parties of interest but it is also the entry point for any chat related communication and this is where the bot needs to plug-in. So for the purpose of this post, the page needs to be something very simple.

Navigate to Facebook Pages.
Click on Create a page and Community or Public Figure and Get Started.
Name the page Example Private Messenger Bot and as category choose something appropriate e.g. Personal Blog.
You can upload pictures for the page if you want to but it is not necessary.
The page should be ready like this Example Private Messenger Bot. Notice that the page can be discovered by others. Confirm this by navigating to your page with an incognito tab.
Go to Setting->General->Page Visibility and select Page unpublished and chose Other for reason with e.g. Personal Bot. Notice that the page is not available any longer on the incognito tab.
From Setting->Messaging use the Your Messenger URL to initiate a chat session with your page. This is the private session we need with our chatbot.

Creating the bot

Developing an actual bot on Messenger is quite complicated. You would need to create an application, submit policies to be able to get keys and tokens that would allow you to integrate with the page's application. For this reason, we'll keep this simple and use a service that makes things very simple. There are three options in order of complexity:

Given that the purpose here is to create a simple private Messenger bot, I'll choose chatfuel for the purpose of this post. Just select Add blank bot on chatfuel and let's name it Example Private Messenger Bot as well.

The bot is now available and you can try a test chat with it by activating the Test Your Bot from the Automate panel within the bot's configuration.

Connecting the bot to your page

This is not necessary, but it helps that you can discover your bot from Messenger or Facebook through the page we just created. If this is your first time in chatfuel then this is straight forward when connecting first time chatfuel with Facebook. The trickier flow that I will explain is when you've already made this connection and you need to find the new page. I've chosen this flow because I ran into this problem when writing this post. I've already have another bot connected with another Facebook page and I couldn't find how to connect the Example Private Messenger Bot to its respected page.

Navigate to Facebook's Business Integration.
Select View and edit of the Chatfuel application.
Scroll down and select the Example Private Messenger Bot on each of the following sections:
1. Manage your Pages.
2. Manage and access Page conversations in Messenger
3. Send messages from Pages you manage at any time after the first user interaction
4. Show a list of the Pages you manage
5. Log events on your Page's behalf and send those events to Facebook
Save.
Wait for a short time and then refresh chatfuel. If this doesn't work try to logout and login again.
Enter the Example Private Messenger Bot and select the Configuration panel from the left.
Notice that the Example Private Messenger Bot is listed with a Connect to Page button to the right which you activate.

That's it.

Integrating with Zapier

On my previous post Creating a private Telegram chatbot I've explained how to send messages to the bot. This allows for any integration with e.g. Zapier or Integromat. To demonstrate the ability to send messages to the Example Private Messenger Bot I'll show how to hook it up with Zapier which offers an integration. To keep it simple and focused on chatfuel and this post, I'll use a two-step zap.

Schedule by Zapier configured to activate every hour.
chatfuel configured to target a session with the Example Private Messenger Bot.

The Schedule by Zapier configuration is very easy and straightforward. Zapier is good at helping configuration with UI navigation. The chatfuel configuration is the trickier one and it compromises by two activities in the overall zap flow.

Find a Subscriber in Chatfuel
Send Text Message in Chatfuel

It will look like this:

To configure the Find a Subscriber in Chatfuel follow these steps:

Type or select chatfuel.
For the Choose Action Event, scroll down and select Find a Subscriber. This step is important and retrieves a value that helps target the session to send the message later on. In more advanced flow, this value is driven as a reaction to an incoming trigger.
For the Chatfuel account select Add a New Account which will open a page and there select the Example Private Messenger Bot to connect with.
For the Search Type there are multiple options. Let's choose the Search by {{messenger user id}} which is the user page-scoped ID (PSID).
For the User ID follow these steps to retrieve it:
1. Make sure you have exchanged one or two messages with the bot.
2. Navigate to chatfuel's Example Private Messenger Bot's page.
3. Open the People panel and you should see your name on the list.
4. Open your entry and scroll down to get the value from messenger user id which is the value to fill in the User ID on Zapier
Activate the TEST & REVIEW to confirm.

It will look like this:

To configure the Send Text Message in Chatfuel follow these steps:

Type or select chatfuel.
For the Choose Action Event field, select Send Text Message.
For the Chatfuel account field select the account that was created Chatfuel Example Private Messenger Bot.
For the Subscriber field select from the previous activity the Chatfuel User ID.
For the Message Tag field, just choose Update.
For the "Message Textfield, just enterTest from Zapier`.
Activate the TEST & REVIEW to confirm.

It will look like this:

And on Messenger it will look like this:

Creating a private Telegram chatbot

Alex Sarafian — Wed, 25 Mar 2020 16:15:00 +0000

If you need a bot for your personal home automation, then this post describes how to achieve what is perceived as a private bot on Telegram.

In this post, I want to explain how to create a private bot in Telegram. With private, I'm referring to bots that are not possible to be found by others or won't interact with others. These sort of bots are meant usually for some personal automation, where the bot act as the delivery entity to you or your family.

Not exactly a private bot

With Telegram bots are not private. Everybody can find them. The difference is that a certain communication channel with the bot can be made private. This is a group with the bot that you and the bot are members of. This sort of private channels is usually useful for home automation, where the bot is to speak with one person only.

Creating the bot

Creating the bot is generally easy by following instructions on Bots: An introduction for developers using the BotFather.

Open a session with BotFather.
Enter /newbot.
Enter the name of the bot. Example Bot for Blog
Enter a username for the bot. it must end with bot. example_blog_bot

Me, [25.03.20 16:02]
/newbot

BotFather, [25.03.20 16:02]
Alright, a new bot. How are we going to call it? Please choose a name for > your bot.

Me, [25.03.20 16:03]
Example Bot for Blog

BotFather, [25.03.20 16:03]
Good. Now let's choose a username for your bot. It must end in bot. Like > this, for example: TetrisBot or tetris_bot.

Me, [25.03.20 16:03]
example_blog_bot

BotFather, [25.03.20 16:03]
Done! Congratulations on your new bot. You will find it at t.me/> example_blog_bot. You can now add a description, about section and profile > picture for your bot, see /help for a list of commands. By the way, when > you've finished creating your cool bot, ping our Bot Support if you want a > better username for it. Just make sure the bot is fully operational before > you do this.

Use this token to access the HTTP API:
1101361374:AAHS_DYrAUohT-HQXVKKz-M1howAxvXdRLA
Keep your token secure and store it safely, it can be used by anyone to > control your bot.

For a description of the Bot API, see this page: https://core.telegram.org/> bots/api

That's it. The new bot is available and anyone can find it as Example Bot for Blog.

The bot has been deleted and therefore all sensitive information is irrelevant.

Create a group with your bot

This is a simple step. We need to do this now because afterward, we will disable the ability of the bot to be added into conversations.

This group we have created is going to be also our private chat with the bot.

Disable joining groups

By default, the bot can be added to a group conversation by anybody who can find it. To make sure this doesn't happen, we need to disable this.

Open a session with BotFather.
Enter /setjoingroups.
Enter the name of the bot. @example_blog_bot.
Enter Disable

Me, [25.03.20 16:13]
/setjoingroups

BotFather, [25.03.20 16:13]
Choose a bot to change group membership settings.

Me, [25.03.20 16:13]
@example_blog_bot

BotFather, [25.03.20 16:13]
'Enable' - bot can be added to groups.
'Disable' - block group invitations, the bot can't be added to groups.
Current status is: ENABLED

Me, [25.03.20 16:13]
Disable

BotFather, [25.03.20 16:13]
Success! The new status is: DISABLED. /help

If you try to add your bot into a group, you can't. So it is best that you already start a group with it before doing this step. You can always enable the group joining feature, create a group with it and yourself and then disable it again.

Interacting with the bot

In the Telegram Bot API the API of Telegram is described. To interact with this bot we need the API token 1101361374:AAHS_DYrAUohT-HQXVKKz-M1howAxvXdRLA which the BotFather provided to us. The general uri pattern is https://api.telegram.org/bot<token>/METHOD_NAME. Notice that the token follows the word bot in the URL.

For example the getMe method will provide information about the bot. Just do a GET with this URL https://api.telegram.org/bot1101361374:AAHS_DYrAUohT-HQXVKKz-M1howAxvXdRLA/getMe.

{
   "ok":true,
   "result":{
      "id":1101361374,
      "is_bot":true,
      "first_name":"Example Bot for Blog",
      "username":"example_blog_bot",
      "can_join_groups":false,
      "can_read_all_group_messages":false,
      "supports_inline_queries":false
   }
}

To send messages to this private group we've created with the bot, we will need to target it by providing the chat_id parameter that represents this group. The chat_id is also necessary for all integrations with other tools like Zapier or Integromat and this is why it is important.

To extract it use the getUpdates method. Do a GET with this URL https://api.telegram.org/bot1101361374:AAHS_DYrAUohT-HQXVKKz-M1howAxvXdRLA/getUpdates. If the result is empty then just type something to the bot in this group.

Note that this method returns results only when the bot is not enabled for privacy. If you want to enable privacy, make sure you do it after extracting the chat_id as explained below.

{
   "ok":true,
   "result":[
      {
         "update_id":726362299,
         "message":{
            "message_id":3,
            "from":{
               "id":877419474,
               "is_bot":false,
               "first_name":"Alex",
               "last_name":"Sarafian"
            },
            "chat":{
               "id":-475387861,
               "title":"Example Blog Bot",
               "type":"group",
               "all_members_are_administrators":true
            },
            "date":1585150611,
            "text":"Hello"
         }
      }
   ]
}

Hello is the message I had sent to the bot to make sure I could get results with getUpdates.

From the JSON, the chat_id is -475387861. We can use this send a message using the sendMessage method.

The sendMethod is much more complicated but for the purposes of this demonstration, a simple GET with a simple message will suffice like this URL https://api.telegram.org/bot1101361374:AAHS_DYrAUohT-HQXVKKz-M1howAxvXdRLA/sendMessage?chat_id=-475387861&text=Hello.

{
   "ok":true,
   "result":{
      "message_id":4,
      "from":{
         "id":1101361374,
         "is_bot":true,
         "first_name":"Example Bot for Blog",
         "username":"example_blog_bot"
      },
      "chat":{
         "id":-475387861,
         "title":"Example Blog Bot",
         "type":"group",
         "all_members_are_administrators":true
      },
      "date":1585151160,
      "text":"Hello"
   }
}

And this has happened in the group with the bot

Me, [25.03.20 16:36]
Hello

Example Bot for Blog, [25.03.20 16:46]
Hello

Configuring for privacy

To enable encryption of the communication with the bot, you must enable the privacy feature.

Open a session with BotFather.
Enter /setprivacy.
Enter the name of the bot. @example_blog_bot. Note that the @ is required.
Enter Enable

Me, [25.03.20 16:09]
/setprivacy

BotFather, [25.03.20 16:09]
Choose a bot to change group messages settings.

Me, [25.03.20 16:09]
@example_blog_bot

BotFather, [25.03.20 16:09]
'Enable' - your bot will only receive messages that either start with the '/' > symbol or mention the bot by username.
'Disable' - your bot will receive all messages that people send to groups.
Current status is: ENABLED

Me, [25.03.20 16:09]
Enable

BotFather, [25.03.20 16:09]
Success! The new status is: ENABLED. /help

Remember that after doing this the getUpdates method from the API will return empty results or the last encrypted message.

Low (No) Code tools from a software engineer's perspective

Alex Sarafian — Wed, 25 Mar 2020 16:12:28 +0000

I've always had reservations for such tools and decided to take a look into this world of low (no) code tools. If you are looking for a light weight look into Buble, AirTable, Adalo, dashdash, Zapier, Integromat, chatfuel, ManyChat and others from a software engineer's perspective, then this is your post.

Overcoming initial reservations

Full disclaimer here, my background in software engineering made me always suspicious about such type of tools or accelerators. Historically, we had plenty of them and they all performed the necessary function but with a huge price to pay in the long term. Who doesn't remember applications built in Access or even fancy Excel sheets driving big organization businesses? Anyone who has worked in a big organization has noticed a big amount of work being done in Excel sheets that are moved around by emails. But the temptation is big because it looks so easy at the beginning but it is also very easy to move from a convenience to a disaster. Applications in Excel sheets don't scale. We had to wait for Google Docs to show to the world on how to collaborate on the same resource online and that is still tricky. Microsoft's Office 365 collaboration is possible but still not very functional and the reality is that many people haven't picked up on the idea. Just mentioning the concept is for most like rocket science and this is not a technical topic but merely one of efficiency and productivity. Then we had the rise of the workflows with all the promises of business people configuring and running their processes without the necessity of the developers but we all know how that went as well. At the moment, some basic logic needed to be implemented, the developer was necessary which kind of beats the purpose. Yes it takes longer to setup an actual application but the longer term benefits are well worth the effort.

So, if I'm so negative about such tools why this blog post? Some time ago I started following the podcasts of Software Engineering Daily and one of the most interesting ones I listened to was Makerpad: Low Code Tools with Ben Tossell. I was impressed to be honest because the host Jeff Meyerson who expressed similar reservations to mine seemed to be at least intrigued and towards changing his mind. So I decided to look deeper into this.

Please keep in mind that this blog post is written by a person of strong technical background and it oriented towards an audience with similar understanding. Non technical people, might get confused and I'm sure that other articles would be more appropriate. Still, if you want to read the side of the story of those who build software applications, then by all means please read this post as well because it will provide some interesting remarks about the limitations of these tools from a long term and technical standpoint. I'm not going to go heavy on the technical so it won't be difficult to follow.

Quick and dirty investigation

Initially, I found two very nice links that provide a list and a summary of each service

Some of the tools are known. For example WordPress is a web site development and hosting tool that has a long and lasting history, starting from a blog engine and evolved to include more versatile flows.

My discovery and filtering process

After reading a bit on each service's website, watching some YouTube videos when available, I've kept only the ones that I've found the most interesting to do a deeper check.

But each person has different drivers and I want first to explain my drivers and conditions that led to this smaller filtered list.

Genuine curiosity. This is my strongest driver of them all. Note to myself, I should be doing this more frequently.
At the aviation-related organization where I work there is some discussion about automating certain flows of different departments. While all fancy words are thrown into the mix, the typical culture is to buy a big fancy tool when simpler solutions or a bit of code could just suffice. After all, there are so much plethora of fancy services, that the hardest parts of the flow are available as a SAAS and only some glue code is required. The constant problem is that nobody wants to see a console to help make the automation simple.
Recently I thought of an application that is missing. Like discussed in the podcast, I'm not keen on developing the entire stack and if there would be something that could help me prototype then that would be the best.
In the past, I had used some PowerShell automation to develop a website for cheap weekend escapes in Europe with RyanAir. I've discussed this in a previous post. For various reasons that are related with restrictions from RyanAir's API, this stopped being functional but if these low code tools can help then why not.
This became important while already in my discovery process. Without going into much detail, because of the Coronavirus disease 2019 I want to get to somehow in my cell phone notifications of specific emails and calendar events.
For a long time now I've been contemplating with the idea of having a chat bot representative of myself for recruiters. This could help both of us spare time but I'm not sure the culture is there for Belgium. Regardless, this is still on mind and I would like to give it a try.

During this process, my main condition was wether the tool or service has a free pricing tier. I quickly noticed that these tools can be very expensive and I'm not going to do full registrations for just exploring them. Also, although this didn't drive my filtering process, I started looking into whether the service provides support for automation pipelines like Zapier. Later on, I discovered Integromat as well.

The tools and services of interest

At the moment of writing this post, I've not investigated all the services mentioned here. But, I've seen enough to know what to expect. Below, I'll split the tools into groups of how I understand with a technical background and share some insight and comments

WebSite builders

This category is about developing a website with visual flows.

Name	Observations
Bubble	Builds web and mobile applications without code. Looks very powerful and requires a lot of digging around
WIX Corvid	An open development platform that lets you build advanced web applications with a visual editor. I haven't checked it yet but from what I read is very good as well.

Everything you would expect is supported by this applications. Form validations, grids, connections with data stores, authentication and authorization. It's all there including a quite a lot of options for design.

Mobile app builders

Nowadays, there is little difference between a website and a mobile application. Still, the ability to produce an application that is published for Android or IOS is quite the differentiator.

Name	Observations
Bubble	Builds web and mobile applications without code. Looks very powerful and requires a lot of digging around
Adalo	Builds mobile application following the flow of a slide deck. Restricted and focused on creating very presentation-oriented mobile applications. Think of basic mobile applications that exist for marketing purposes or just to provide a presence and an entry into your brand.
Glide and Sheet2Site	I've not worked with them yet, but these tools seem to offer an even simpler case of Adalo, where instead of slide-show driven flow, the app will present based on a template, items from a Google spreadsheet. Add picture links on the sheet and you can have a very nice look.

Database like

Although the tools themselves don't identify themselves as databases, in my view they are or all about data with some very interesting extra features.

Name	Observations
Airtable	This the closest to a database concept with rules of validation for columns and linking entities. On top, it can create very interesting and fancy views of the data. It offers API to interact with the data. As far as I've seen it only supports integration with Zapier
dashdash	This is a spreadsheet on steroids. While on beta at this moment of writing this post, what it does is that it can enhance or react upon a column on a row by driving an external API. It can also create the sheet by expanding on the results of an API call. Interesting and very focused for specific needs

Automation workflows

These tools are all about creating flows that react on some external stimulus, do some data processing and then usually push that data to other external services, very similar to the traditional concept of workflows. For example, you can react upon a tweet, run it through a sentiment analysis engine and notify the appropriate person or group.

Name	Observations
Zapier	Probably the most mature service of them all. It is the only one that has integrations that allow the flow or zap, as they call it, to execute as a reaction to external events. Developers would know this pattern as a webhook integration which is used quite a lot in the CI/CD world.
Integromat	Very similar to Zapier and looks more elegant and elaborate. It allows conditional flows in a bit different way. At this moment all flows are scheduled on intervals.
ActionDesk	I've not checked this yet because I'm still waiting for admission but from what I read this is supposed to be a child of Airtable and dashdash

What I found limiting on both tools is that they are very simple flow oriented. Normal workflows allow conditional and loop patterns but these tools don't. This could be to avoid driving non-technical profiles away.

Notebook style collaborations

Both Notion and Coda allow the mix of functional with text. You can create wiki-like content, planning, to-do lists etc. The difference with Airtable is that these tools are more focused on the mix and the page and the data is there just for the embedding. They are quite powerful and act as a self-contained application.

They remind me a bit of the concept of a Jupyter Notebookwhere the mix of text and execution blocks from code is amazing. Opem the notebook, run it and voila you get some very rich page with dynamic table and charts to share and print. With these notebooks, the code is very visible and scary for many people but when I spoke with dashdash, they showed me an upcoming feature that resembles such a functionality. I think if Notion, [Code] and dashdash could provide such a feature, where instead of python code you just see and interact with a grid or chart then this could be a killer feature in my opinion.

Chatbots

If you have tried creating a chatbot then you know that this is not easy when it needs to be proper. It is not just that the logic is difficult but also that hosting the bot can be also very difficult with Facebook's messenger being the most demanding in my opinion to a fault. These tools allow a person to develop a chatbot application in a similar way to creating a website with e.g. Bubble but now instead of screens, you get dialogues.

Like Bubble and WIX Corvid, ManyChat and chatfuel can go deep in creating advanced functionality so I skipped this for now. What I ended up using them for is to send messages to messenger to use as notification on my cell phone. When I tried creating my application on Facebook to integrate with Zapier I kind of gave up and I found these tools to be a simpler alternative.

Drawbacks

To my knowledge, none of these applications has this concept of change management and releases. I believe Bubble has this concept, where you have a developer version website to experiment and the actual production one. Still, the process of change management, that is being able to review the changes while implementing features, is not there. Maybe it would be too scary for some people but in my opinion, this is a very important feature when collaborating.

I've also noticed that many of these services can become expensive especially if you need to combine some of them. But this is something to be evaluated on a case by case basis. Like many accelerators, you get what you want fast and cheap but in the long term you might end up paying double and triple the cost.

Low-Code or No-Code

There seems to be a confusion about whether to use the terms low-code or no-code. Although the marketing is oriented towards people who don't want to see any code, most of these tools require some basic understandings of how code works and hence the proper term is low-code. It is not that one needs to understand code but it is good that some very programming principles like conditions, loops, variables, assignments, HTTP, rest, authentication, authorization etc are understood. Things have changed, and I'm sure that younger people are not so alienating or dismissing to these basic concepts because they are very much familiarized with technology since children. This is also something to keep in mind when trying to understand for who these applications and services are primarily intended for.

Conclusion

I have to admit, I'm convinced. Not entirely but let me elaborate.

With proper understanding the scope and limitations of these tools you can have some serious things created. You don't have to pay for marketing apps if you have some creativity and you can have a basic interaction through a chat interface. What troubles me the most is the lack of change management. Maybe it's the software engineer inside me that is so concerned. For most basic applications that are oriented to serve information and help the brand grow, this would be an overkill. But when teams are involved and when bidirectional flows are implemented, then I'm concerned. Not sure if I would ever run serious production loads on the likes of Bubble, AirTable, ManyChat and Zapier. I would still advice to use these tools though for rapid prototyping. It is just that I know from experience, how a monster can be created by such tools when the prototype becomes the workhorse. If your company is your one-man show, then don't look elsewhere. There is incredible power here.

The problem with regional settings/formatting from an expat's viewpoint

Alex Sarafian — Thu, 02 Jan 2020 22:28:16 +0000

I'm from Greece which means non latin alphabet in the local language. Like many other Greek people who grew up in the 80s with a passion for technology before it became mainstream, we dislike and often hate Greek in any technology product as often the translations were and still are funny and it was also a safer option before the wide adoption of Unicode. This is not a unique attribute to the Greek technology forum but something quite common especially to countries with non-latin based alphabets.

Before everything became an online SAAS, this was not such a big problem. Install Windows with English (United States), add the Greek language and the change the date formatting to dd/mm/yyyy. Only problem was with Office applications and especially Excel with numerical values. Depending on the active language there was a problem with . and , when enterring numerical values.

Now that everything's online, location in the operating system is important because it drives the online services and content. We also use the online variant of applications like Excel from different devices and sometimes from different locations.

In 2011 I've moved to Belgium which has French, Dutch and a bit of German as local languages (Yes I know, oversimplified analysis). I've spoken with many Flemish (the Dutch speaking population) and those with similar age to mine also preferred English as their technology language. It wasn't as intense as with nationalities with non-latin alphabets but it is still recognizable. During the same period I transitioned into smartphones. First it was Windows Phone, then Android 4, then Windows Phone and finally Android.

To summarize: I live in a country with multiple languages (mainly Dutch and French), prefer all technology stuff in a non local language (English) and I often mix content with a non-latin alphabet language (English+Greek).

On my Android phone I've never had issues with regions etc. Very simple to be honest. I find the experience on Android a much better one than Windows and Windows Phone mostly because I find that Microsoft tries too much to derive settings and takes control from the user. You see this difference when accessing an excel file from your home and work computer either on the browser or with the location application. Compared to Android app experience, it is so confusing and unproductive especially when I need to switch languages. For example, when openning the same excel file from the Android app, it just works. No mix up with . and , for the decimal point. It just works as with many other things that kind of make the Windows desktop OS feel like buggy.

Numerical entries should work with the numeric pad but when the decimal function changes all the time then mistakes happen often. To be fair to Microsoft, Android usage doesn't include a numeric pad nor have I used Google OS with a full desktop keyboard. So the "my just works" could be incorrect but my point is still that it should still work everywhere this simple.

The above example with Excel is one of the problems. I focused on it because it is the easiest one to explain especially to people who are used to only one language in their life in technology products. Let's go over a more complicated example which is derived by a mix of being expat and IT organizational policies.

Let's take Office 365 as an example. First time you login with your professional account it needs to initialize to the profile. Part of the initialization is about localization and regions for which the user is not asked. My current employer utilizes a sort of a randomization for proxies that have IPs from different countries. You can immediately recognize this from the first access to google.com or maps.google.com. My proxy is one with a French IP.

Let's compare the Google and Microsoft experience.

Google search:

Browse to google.com and you get redirected to google's french website.
Scroll down and choose English. Easy to recognize. It is not even written in French.
Done. That's it.

Office 365:

Browse to any of their services.
Authenticate with organization account.
Profile gets initialized and everything is in French.
Go to Outlook and change language relatively easily to English.
Go to any office app or onedrive and get mixes toolbars with french and english.
Wonder why the setting I've already changed in step 4 isn't working.
Go home, access the same account and it is still in French.
Navigate in settings that are all in French? Not easy if you don't know French.
Ask IT. They haven't thought about it.
Google it. Yes it is in English.
Follow the instructions here

Every action within each of the Word, Excel, Powerpoint, OneNote etc applications of the Office 365 has the same behavior.

Here is another problem which is also the reason I decided to write about this. I recently formatted my Windows OS. I wanted to play nice and be accurate with the information I provided. I usually set all the English United States and add the Greek language but I though maybe things have changed. This is what I did:

Chose Belgium as region instead of United States that I usually do
Added English (International), Greek and removed French and Dutch keyboards
Chose English (UK) for the formatting, because it matches better the date and metric and it is in English compared to the Belgium counterparts.

Somehow the Windows OS adds a third language (English UK) no matter how many times I've removed it just because the formatting is English UK. But I don't want another entry in my keyboard. I need to rotate between an English and Greek and an additional English language creates problems because you often end up switching from English to English but from international layout to UK layout.

I'm not saying that Google is perfect but considering the user experience it is much better, less confusing and less frustrating than the experience with Microsoft. It is not about which product is better or not but how much and how hard the system tries to help the user and instead ends up working against him or her. It seems to me that Google has better realized their global customer reach than Microsoft and has chosen to leave some UX aspects to manual or I could be mistaken because an android phone is much simpler compared to a desktop keyboard. Still, the small device makes the big device look like buggy.

Why is this important? Because movement for work is ever increasing in the world without staying within the boundaries of one country. Take the European Union for example which combined is a much bigger population than USA with incredible variety. To help understand non-EU citizens, this is EU again over simplified.

Each member country has a strong history and is very opinionated about regional things.
None of the remaining member countries (BREXIT) has English as official language.
English is the professional language because the rest of the world speaks English as well and because the French, Germans, Spanish and Italians had no intention of speaking of anything else and English is a global necessity.
There is a freedom of movement to live and work, kind of similar to the EU area being one country.

In this trillion dollar economy there is a problem which technology doesn't seem to have solved. I understand that it is not easy because localization and regional support is not an easy problem to tackle. Most of us take this for granted but like date/time it is much more of a challenge than we most understand. DateTime has to function otherwise things break but regional settings don't, like I've experienced. Date/Time related solutions are focused on functional accuracy and got it mostly correct where regional settings solutions are focused on UX and it depends on who you ask if they got it correctly. In a world that seems to globalize, until we all agree into one English international language, settings and metric system, it seems to me that something is being done wrongly.

My proposals:

Let the user specify independently the location, region and input methods. Don't derive any conclusions and don't take any actions on behalf of the user.
Drive this with a smaller scope. Give the user control per application or even better per resource. Do it like the portable applications have been doing.
If possible, do this with an override settings not to upset the status quo.
Most importantly, make it easy to find or control.

I'm aware that this could be similar to the feature requests to the Microsoft Office team before the introduction of the ribbon bar. 90% of them were already available but users didn't know where they were. I'm sure that some of the solutions issues are like this and there is already a solution through some option somewhere, like the one explained for office 365. Regardless, I stand by making it easy to find or control.

I'm really interested into your opinions about this topic. Do you face similar problems? If yes please mention origin, location and your tricks and tips in your comments?

Some explanations were over simplified to avoid losing focus into complicated issues in the European Union. I hope you understand.

Building Careers with Empathy with Scott Hanselman

Alex Sarafian — Fri, 18 Oct 2019 07:04:15 +0000

I thought to share visibility on this career and life video both the perspective of the person growing but also from when you become a coach.

There are a couple of important topics I would like to put focus on:

You, the experienced person have "life to spare" when a stupid question is required to be asked. Your younger and just starting counterpart doesn't. So don't be afraid to take a hit
Always understand where your code is being executed. This is for me a big problem currently in the industry.
Visibility and sharing of knowledge.
Luck is necessary. Skill as well. Having skills is a lucky thing to be born with.

Especially on the topic of luck and skill, it is very rare when an American, especially with a successful career, recognizes that it is not just a matter of hard work but also luck and coincidence are necessary to succeed in life. If it is not luck then it is lack of unlucky moments. This is something that we tend to forget when we judge other people and personally frustrates me. There can be many things that could have gone wrong for a person but also many things that just go right to others. If you are one of the lucky ones, then you should be respectful to those who weren't.

I also find this "building careers" series of interviews happening at Microsoft very interesting.

PS, There is something about Scott Hanselman's presence that puts me off but it is just me. Nevertheless, I find most of what he says and writes about exceptionally insightful with a lot of honestly, pragmatism and simple reasoning.