DEV Community: LG

Git bash for Windows users PS1 variable (aka prompt) customization

LG — Fri, 22 Dec 2023 14:09:17 +0000

This assumes that you are located in %USERPROFILE% (File Explorer), otherwise, init Git bash for Windows shell session at cd ~: once you are there, touch .bash_profile via Git the bash session. Following these third-party guidelines (see link) we can customize our PS1 as we want to:

MY_ALIAS="vanillacamp"
export PS1='\e[0;32m$MY_ALIAS@\[\033[35m\]$MSYSTEM \[\033[33m\]\w\[\033[36m\]`__git_ps1`\[\033[0m\]\n$ '

Let's clarify the snippet above:

MY_ALIAS is a bash variable, that later on will be referred to using a dollar sign as the following: $MY_ALIAS

the export keyword makes sure the PS1 will be valid among sessions (system-wise)

PS1 variables follow ANSI-escaping standards for colouring and formatting including some special escape sequences such as \u for system (admin) username, or relevant

the $MSYSTEM is part of MSYS2 toolchain; depending on platform $MSYSTEM most likely be one of the following values: MINGW32|MINGW64|MSYS

__git_ps1 is part of Git version control that, essentially, provides the current branch as part of your prompt, thus PS1 variable you currently trying to modify

Happy modifying, cheers!

More explicit interface implementation in Go using simple function signature | 3 ed.

LG — Fri, 06 Jan 2023 23:47:15 +0000

NOTE : Go and Golang – are synonyms !

Rather than implicitly stating methodSignature() methodType without any reserved keyword such as implement for method we can write what I call "JavaScript-like callback" i.e. function that wraps interface signature(s) for more explicit interface implementation based upon an arbitrary named convention [2 example]

1 Example – consider initial pseudo_code (Go syntax) :

type someInterface interface {
    methodSignature() methodType
}

// empty struct is still a valid entity to define a method
type yourStruct struct {
  // struct field[s] (if any)
}

func (receiver yourStruct) methodSignature() methodType {
  // method logic
}

2 Example – consider the following optimised pseudo_code (Go syntax) :


package main

import . "fmt"

type someInterface interface {
    methodSignature() methodType
}

// 1/3 empty struct is still a valid entity to define a method
type yourStruct struct {
  // struct field[s] (if any) : empty string would be still valid 
    someType string
}

// 3/3A : wrapper for more explicit interface implementation
func explicitInterface〳implements(interfaceReceiver someInterface){
    interfaceReceiver.methodSignature()
}

// 2/3
func (structAccessor yourStruct) explicitInterface〳implements() /* 3/3B : <= as if written someInterface.methodSignature() but in Golang syntax-enforced fashion  */ {
    Println("Engineering name: " + structAccessor.someType)
}

Practical example (REPL) :

Runnable code example on REPLIT

Open shell instance and type: go run explicitInterfaceImplementation.go # <= this might change in the future so don't think hard, think smart !

If you found any typo, or think you can suggest a better solution, please leave a comment below . Stay tuned for more coming from Go . Cheers !

Most sophisticated embedding pattern in Go: embedded interface within a struct

LG — Fri, 06 Jan 2023 20:03:39 +0000

From my point of view, this pattern is one of many explanatory examples, but should be learnt by heart until completely comprehended . It's like writing an explicit callback for another callback in JavaScript – takes time to make a final "Gotcha!"

package main

import (
    . "fmt"
)

// 1.3) define interface siganture(s)
type Logic interface {
    Process (data string) string // # signature 1
    /* Argc (data []string) int  */// # signature 2 : keeping 2 as commented out 
}

// 1.1) empty struct is prerequisite to provide a method
type MethodProvider struct {
    isEmpty bool
}

// 1.2) thanks to empty struct above we can define method that will be our implicitly implemented Logic interface field i.e. Process in this case;
// Process method with returning type, in this case, it's a (labeled .......string)
func (methodReceiver MethodProvider) Process(data string) (methodReturnType string) {
    // business logic
    if !methodReceiver.isEmpty {
        Println(data)
    }
    return "methodReceiver that provides implicit Logic.Process signature implementation";
}

// DEV_NOTE: another struct embedding Logic.Process : we say Client "HAS" (i.e. "EMBEDS") Logic.Process not "IS" as embedding vs. inheriting is not the same !
type ClientProvider struct{
    LogicImplementor /* <= is an alias for => */ Logic /* interface */
}

// Program method with returning type, in this case, it's a .....string
func(clientReceiver ClientProvider) Program(pseudo_argv0 string) string {
 // get data from somewhere
    clientReceiver.LogicImplementor.Process("Client Process")
    return "Exit with pseudo code 0";
}

func main() {
    c := ClientProvider{
        LogicImplementor: MethodProvider{},
    }
    Println(c.Program("$PATH_TO_pseudo_argv0.exe"))
}

runnable code example on REPLIT

Open shell instance and type: go run embedded-interf2--advanced.go # <= this might change in the future so don't think hard, think smart !

If you found any typo, or think you can suggest a better solution, please leave a comment below . Stay tuned !

Golang encapsulation for protected fields – quick insight

LG — Tue, 03 Jan 2023 22:45:38 +0000

My personal insight (TL;DR) :

"A struct encapsulation within dedicated module with structs' un-exported fields, but exported setter-like and getter-like method(s) within such dedicated module yields similar practice of protected class behaviour in such languages as e.g. – PHP"

TypeScript for prototyping: bijective function example with generics' notation

LG — Mon, 02 Jan 2023 21:03:13 +0000

Bijective function (one-to-one correspondence) function in layman's terms with TypeScript generic notation:

function bijective<input, output>(arg1: input, arg2: output): void /* <= instead of "return;" do "void" */ {
   console.log(`${arg1}=>${arg2}`);
   /* return; */
}

bijective<number,boolean>(0, false) // #  "0=>false" 
bijective<number,boolean>(1, true) // # "1=>true"

Carbon-design-system for Svelte: dynamic import is your only solution !

LG — Thu, 22 Dec 2022 22:26:46 +0000

DISCLAIMER: install sveltekit, carbon design with sveltekit+vite works out of the box !

I've opened issue on IBM community to find a solution rather than importing via <svelte:head>, although I could not even get any answer to that . After sometime of scratching my head and couple of tests on Webpack behaviour, I've managed to crack carbon-design-system for Svelte once and for all . Repeating myself:

POSSIBLE REASON WHY WE NEED DYNAMIC IMPORT RATHER THAN STATIC ONE IS : Svelte acts asynchronously subsequently static import at svelte compiler build stage has not YET registered Carbon-design, in order to upload the Carbon-design theme files (CSS) via Svelte to Dom stage, common sense, you must use dynamic import, onMount cycle just makes sure theming would load within first Svelte load

package.json

// webpack.config.js
...
 resolve: {
    modules: [
      'node_modules'
    ],
}
...

App.svelte

// App.svelte
        onMount(async ()=>{
            // e.g. import ./white.css theme:
            await import("carbon-components-svelte/css/white.css")
       })

Enjoy coding with Svelte <3

Type checking in Go – alternative approach

LG — Tue, 20 Dec 2022 22:28:15 +0000

Instead of reflect.Valueof(<variable>).Kind() we can think about implementing this _switch wrapper :

NOTE: I cannot ensure which is better, but thumb of rule is baked-in features should be faster, more efficient ? – Remains a question . Still as alternative approach consider the following :

JavaScript web__constants (Node.js-friendly)

LG — Thu, 08 Dec 2022 20:44:05 +0000

Intro

All magic based upon import.meta operator natively baked-in on ES6 modules (ESM)

Bear in mind the following:

/* --- This is also mentioned in the code ---
URL scheme depending on :
a) server (web, Node.js) => http(s)://
b) file-system (Node.js only) => file:///
*/

Open sanbox in a dedicated tab & run the following on a shell:

node index.mjs

Initial konva-svelte public pre-release

LG — Sat, 29 Oct 2022 21:41:19 +0000

React for Konva ? - Of cource !, Vue for Konva ? – Of cource, Finally, Svelte for Konva, here it go :

svelte-konva

Map-based (functional) namespacing

LG — Thu, 20 Oct 2022 23:55:37 +0000

Motivation

As far as I know PHP is lack of definition of modular namespacing, although PHP \App-like signature of namespaces is one the features I was missing for ages in JavaScript implementation (ECMAScript specification) . However, it seems we can reproduce similar behaviour via Maps since ES6, except that the signature looks more "Erlangish" (i.e. "functional"), code base :

References :

Git : feature-branch is nth commits behind

LG — Wed, 14 Sep 2022 13:40:06 +0000

The more I work with Git version control , the more I want to write a book from scratch that would be easy to read, that would include maintainable (up-to-date) link to real life examples, including many of developers experience in one precise volume – I already have a vision how it would look like, although it would take time to write one as I am still learning the git fundamentals, not mentioning some of its boring intrinsic parts of the git ...

However, in this post I'd really like share one small issue I've dealt recently with ; consider we worked for a while on feature-branch that remotely (I said not locally, but remotely !) was merged to remote base branch named develop (or main, master – whichever suits your imagination best) : by convention any default merge action is commit action as well – remote develop becomes -ahead, feature-branch becomes -behind (keep in mind it could be a case of -ahead & -behind mixture), which would subsequently make aforementioned remote feature-branch stay N-th of commits -behind (prerequisite : to state that some branch is -ahead or -behind your local copy of feature-branch must be [pre-]tracked with remote one) . In my case it was both -ahead & -behind remotely . Ignore the -ahead part whereas we interested in -behind part only : -ahead part basically says that you made couple of commits ahead, but you have not yet decided to merge it to base branch remotely .

Feature-branch is -behind n-th of commits [solution]

Prerequisites : The solution suggested assumes you are using GitHub Desktop

Instead of two step process i.e. pulling remote develop to update things locally & then merge local develop to the local copy of remote feature-branch, just do one step process what is called "Update from ..." (in my case it was Update from develop) or Ctrl + Shift + P on GitHub Desktop respectively . This action would remove n-th commits -behind message on your GitHub account for feature-branch or any relevant name of your feature-branch .

Svelte : declare component without tags

LG — Sat, 03 Sep 2022 20:47:32 +0000

INTRO

No, this is not one more example of <svelte:component this={Child} /> . This is example whereas you can instantiate Svelte component keeping "React-ish" vibe on the line .

PREREQS : The only prerequisite is that new App({target}) inside index.js & new Component({target}) inside App.svelte would share same target property e.g. as follows :

TIP : try to open codesandbox in the seperate tab, or copy paste to your local environment, as you may experience error "props is not defined" which is not true ;

NOTE BEFORE CODEBASE EXAMINATION : we use refs.js to share target dynamically, although if it's only couple of targets, common sense, we can hard-coded in , although hardcoding is considered bad practice whatsoever ;

NOTE : doing this way we exclude use props, apply inline styling through attributes, moreover this is just some alternative way of instatiating components rather than the mentioned way in the Intro or as e.g. self closing tags <Child />