## Convention of a += operator in pseudo-code

I have to write some algorithm in pseudocode for a paper. For this I have the "$$\leftarrow$$" to assign a value.

$$x \leftarrow y^2$$

now I want to write a method which adds to the variable. In normal Python code I would write `x += 1` for this. Is there a style convention how to layout this in pseudo-code in a paper? I dont really like the redundance of $$x \leftarrow x+1$$.

## Naming convention with no-class-abstraction oriented languages

How to deal with naming convention on no-class-abstraction oriented language like C, Rust, Go etc. Class abstraction pattern hide by design the composition model and allow to avoid repetition when you use it and to have a clean representation. That it’s different without abstraction.

Here an use case for comparison : example with class-abstraction language

``# (python pseudo code) class ContentFile:    contents = Content    file = File  class TemplateContentFile(ContentFile):    template = Template  templateContentFile = TemplateContentFile() ``

Now if I would get the [`contents`] of [`templateContentFile`] we have to write [`templateContentFile.contents`] and we forgot [`ContentFile`] abstraction.

Otherwise with no-class-abstraction language

``// (rust pseudo code) struct ContentFile {     contents: String     file: File }  struct TemplateContentFile {     content_file: ContentFile,     template: Template }  let template_content_file = TemplateContentFile::new(); ``

Now if I would get the [`contents`] of [`template_content_file`] we have to write [`template_content_file.content_file.contents`]. It’s a bit sad to deal with [`ContentFile`] aesthetically speaking :'(.

Well here I don’t speak to achieve that with implementing method/function or any logique programming, but just modeling.

Have you some advice for deal with this issue ? (maybe books/articles too)

## Is there a naming convention for the left child of a right child (and vice versa)?

That is, the right child of a left child, or the left child of a right child. The best that I can come up with is the “opposing child” but I was wondering if anyone has come across an existing naming convention for this.

## Whats the best naming convention for items inside a list/cell using Sketch symbols?

The symbols included in Sketch have this structure for cells (used in list/table):

• Insert > Symbols > iOS UI Design > Cells > Table
• Insert > Symbols > iOS UI Design > Overrides > Cells

Using the word “Overides” makes sense from a Sketch perspective as it explains the function in Sketch, though it does not explain well the placement and usage of the items in the table view cell. Ex. the chevron or toggle switch is usually inside a cell. Also, it pretty confusing having loads of different symbols used across different views under “Overrides”.

This what the cell looks like:

I am therefore trying to figure out what the best naming would be. In iOS https://material.io/components/lists/#behavior they would be objects, while as far as I can see, Material Design doesn’t have one unifying word for this https://material.io/components/lists/#behavior

Words that I find could describe the items could be:

• elements
• components
• properties
• objects

Of these, I find “elements” would be best. What do you call these items that make them easy to find and that one understands that these items are to be used inside a cell?

I need a way to allow users to rate the helpfulness of documentation articles on our docs site. Usabilla is an example of a tool that is created for this (and other things). What other ways exist for collecting and tracking this kind of information?

## Enforce File Naming Convention in a Folder inside a Document Library SharePoint Online

SharePoint Online specific.

I wanted to know if it is possible to enforce file naming conventions at the folder or sub-folder level in a Document Library.

For example, I have a Document library called “Documents” with many sub-folders. I want to enforce a specific file naming convention for all Word (docx) files uploaded to a “Legal” folder, e.g. “Document_Name_Department_MMYYYY”.

Then similarly a different file naming convention in the folder “IT”, etc.

I have found a site that explains how to do it using the CSOM (https://www.tatvasoft.com.au/blog/how-to-implement-remote-event-receiver-in-sharepoint-online/).

Is anyone aware if this is possible using JS, no-code, Azure or Flow? basically an alternative way rather then the CSOM example listed above.

Thanks!

## Sharepoint local folder naming convention

My organisation has moved over to Sharepoint relatively recently; most of the usual teething problems have been ironed out, but this one has been driving the programmers mad:

When we sync a folder from Sharepoint Online, the local file path it creates depends entirely on the level at which we sync. So, if I sync fairly high up, my local file path looks like:

``C:/Users/crowsNose/Department/Projects/Project3/Code/ ``

Whereas, if my colleague just wants to sync the folders for Project3, her local file path looks like:

``C:/Users/crowsColleague/Department - Project3/Code/ ``

…which is very annoying when we’re trying to share code which points to other files within this folder structure.

(We are not having any luck using direct links to files on Sharepoint Online – security settings, I suspect.)

So: is there an option we can check, or something we can ask IT to change, which would give us all the same local folder structure, irrespective of the level at which we sync?

## Tri-state icon convention?

I have to design a report with validations about data introduced. In some fields I have a typical triple state. Let me give an example:

### Documents

• A good file added -> ✓
• A bad file added -> x
• It doesn’t require file -> ?????

That third state “don’t required” … have some standardized icon or similar? I don’t see any good examples in web and I can’t think something recognizable.

Edit: The file which is not required needs an icon because is the final step of the validation and the user can’t upload anything after the report is created

## Git Branching Convention : Baseline from Dev or Master

When creating a new feature branch should i baseline from Master branch or Dev branch and why? I am used to creating a branch from master as the baseline, making my changes and merging it back into dev but recently at my new organisation it was suggested that i create the branch with dev as reference.

## CSS class naming convention

I think every frontend developer knows how BEM works right? If not, that’s okay. Just Google it and you’ll find a LOT of documentation and articles about it. Personally, I love how intuitive and innovative BEM is. For small components, it works like a charm. But as you project requires longer components which happens to require many more DOM tree, you’ll surely need something more.

Let’s supose that you’re developing a full custom theme for an entreprise-level website/blog/ecommerce and you need to make a highly styleable menu. BEM methodology recommend that we style our components based on the following class structure:

``.menu .menu__item .menu--blue ``

But what if you need a child for that `item` element? And another child for that one too?

This is where BEM core concepts starts to fall apart and my “methodology” comes in. You can have as many childs and grandchildren as you need. For example:

``.header .header-menu .header-menu-links .header-menu-links-item-label .header-menu-links-item-icon ``

You may wonder how in the name of God you would add an modifier to that monster. If we were going to do something like this:

``// Wrong  .header-menu-links-item-icon .header-menu-links-item-icon--star ``

Eventually, it would make our markup unreadable. Instead, I propose that we do it like this:

``// Okay  .header-menu-links-item-icon .header-menu-links-item-icon .is-star ``

That way, any class name that starts with `is-` would be a modifier for one of the sibling classes. And for that, you could use inheritance, like this:

``.header .is-theme-purple  .header .is-theme-purple .header-menu .header .is-theme-purple .header-menu-links .header .is-theme-purple .header-menu-links-item  .header .is-active .button .is-lg ``

Here is an markup example of this methodology:

``<div class="menu">     <div class="menu-links">         <div class="menu-links-item is-current">Item 1</div>         <div class="menu-links-item">Item 2</div>         <div class="menu-links-item">Item 3</div>         <div class="menu-links-item">Item 4</div>     </div>     <button class="button is-size-lg is-color-primary is-shadow"></button> </div> ``

Alternatively, you can omit `is` from modifiers turning it into something like `button -lg -primary -shadow`.

Important: While you can obviously use this concept with pure css, it is highly recommended that you use a css preprocessor like SASS.

PS.: Btw, I would like to hear what you guys think about it 🙂