Naming Conventions

-

Naming Conventions is very important for any application for better readability of  code.

What is Naming Convention ?  Naming conventions are general rules applied when creating text scripts for software programming. They have many different purposes, such as adding clarity and uniformity to scripts, readability for third-party applications, and functionality in certain languages and applications. They range from capitalization and punctuation to adding symbols and identifiers to signify certain functions.

Advantages of Naming Conventions are :

1. Consistency
2. Better understanding the code
3. Readability
4. Automation

Types of Naming Conventions: 

1. camelCase : First letter should be lower case.
2. PascalCase :  All words should be upper case.
3. kebab-case : Use dash symbol between word to word with lower case.
4. snake_case : Use underscore symbol between word to word with lower case.




How and where these naming conventions will use ? Please check this post Angular Coding Style Part 1

Comments

Post a Comment

Popular posts from this blog

Create a function to convert from string to Decimal using JavaScript

-
Create a function to convert a string to decimal using JavaScript. Javascript function parseStringToDecimal(inputValue: string): Number { let value: number; if (inputValue === '0.00' || Number(inputValue) === 0.00) { value = 0.00; } else if (inputValue === '') { value = null; } else { value = parseFloat(inputValue.toString().replace(/,/, '')); } return value; } Expected Result :  Example const value = parseStringToDecimal("1,000.256"); console.log(value); Output :  1000.256
Read more

Send API POST Request in MS SQL Server

-
To send an API POST request in MS SQL Server using multipart/form-data, you can use the following T-SQL code: Example of content type : multipart/form-data SQL DECLARE @url VARCHAR(200) = 'https://example.com/api'; DECLARE @boundary VARCHAR(50) = '---------------------------' + CAST(NEWID() AS VARCHAR(36)); DECLARE @param1Name VARCHAR(50) = 'name'; DECLARE @param1Value VARCHAR(50) = 'John Doe'; DECLARE @param2Name VARCHAR(50) = 'email'; DECLARE @param2Value VARCHAR(50) = 'johndoe@example.com'; DECLARE @param3Name VARCHAR(50) = 'file'; DECLARE @param3Value VARBINARY(MAX) = (SELECT BulkColumn FROM OPENROWSET(BULK 'C:\path\to\file.txt', SINGLE_BLOB) AS x); DECLARE @param4Name VARCHAR(50) = 'description'; DECLARE @param4Value VARCHAR(200) = 'This is a sample file'; DECLARE @formData NVARCHAR(MAX) = N'--' + @boundary + CHAR(13) + CHAR(10) + ...
Read more

Clean Architecture in a C#

-
Clean Architecture is a software design pattern that separates the application into independent layers, where each layer has a specific responsibility and interacts with other layers through well-defined interfaces. The main goal of clean architecture is to create a flexible, testable, and maintainable software system. By following this architecture, we have created a flexible, testable, and maintainable software system. The domain layer is independent of any external dependencies and frameworks, making it easy to test and change without affecting other layers. The application layer contains the use cases or application-specific logic, which is decoupled from the infrastructure Here's an example of how to implement Clean Architecture in a C# project: 1. Domain Layer: This layer contains the business logic and domain-specific entities. It should be independent of any external dependencies and frameworks. C# ...
Read more

Domain Driven Design (DDD) in .NET Core

-
Domain-Driven Design (DDD) is an approach to software development that emphasizes the importance of the business domain in the software design process. It is a set of principles and practices aimed at building software systems that are aligned with the business needs and requirements. The main idea behind DDD is to create a shared understanding of the domain model between the domain experts (business stakeholders) and the software developers. This is achieved by using a common language and a set of tools that allow for the domain model to be explicitly represented and manipulated in code. In DDD, the domain model is the central focus of the software design process. It is a representation of the core business concepts and rules that govern the behavior of the system. The domain model is expressed in code using object-oriented programming techniques, and it serves as the backbone of the software system. DDD also introduces several design patterns and ...
Read more

Javascript Hoisting

-
JavaScript hoisting is a mechanism where variable and function declarations are moved to the top of their respective scopes (either the global scope or function scope) during the compilation or interpretation phase, regardless of where they are declared in the source code. This means that even if a variable or function is declared later in the code, it can be used before its actual declaration. However, it is important to note that only the declaration is hoisted, not the initialization or assignment. In other words, if a variable is initialized after its declaration, its value will not be available until after the initialization. Similarly, if a function expression is used, it will not be hoisted, only function declarations are hoisted. JavaScript hoisting can have some advantages and disadvantages. Advantages: Flexibility : Hoisting provides developers with the flexibility to declare functions or variables anywhere in t...
Read more

Map Operator in RxJs

-
The map operator in RxJS is used to transform the emissions of an Observable stream. It applies a function to each emitted value and returns a new Observable with the transformed values. The original values are not modified. The map operator is often used in combination with other operators to create complex data flows. Advantages of the map operator in RxJS include: Transformation of data : The map operator allows you to transform the data emitted by an Observable, which can be very useful for manipulating the data in the way you need it. Efficiency : The map operator is an efficient way to modify data, as it does not modify the original data and creates a new Observable with the transformed data. Composability : The map operator is a composable operator, which means you can combine it with other operators to create more complex data flows. Clarity : Using the map ope...
Read more

HTTP and grPC Communication protocols used in Microservices

-
Microservices architecture is an approach to building distributed systems that involves breaking down a large application into smaller, loosely coupled services that communicate with each other through APIs. There are several communication protocols used in microservices architecture, including HTTP and gRPC. HTTP: HTTP (Hypertext Transfer Protocol) is a widely used protocol for communication between web applications and servers. In microservices architecture, HTTP is used for communication between services as it's a well-established and reliable protocol that's widely supported. HTTP is simple and easy to use, and it supports a wide range of data formats like JSON, XML, and plain text, making it a popular choice for microservices communication. gRPC: gRPC is a modern, high-performance, open-source protocol for communication between microservices. It uses Google's Protocol Buffers as a data format, which is a language-neutral, platform-neu...
Read more

Display PDF Or Tiff Files In IFrame

-
How to  Display PDF Or Tiff Files In IFrame in Asp.net C# Example:  In this application how to display PDF or tiff files in IFrame in asp.net C# . First We have to Know about IFrame ,  The <iframe> tag specifies an inline frame. An inline frame is used to embed another document within the current HTML document. Please Click this link and Know About IFrame Before Using IFrame Tag . Mostly Iframe does not support to show the PDF files Or Tiff Files in Google Chrome and Firefox browsers,Only supports in IE Browser. For my Requirement in this application I want to show the PDF File in IFrame, which is in local shared folder (\\IPAddress\SharedFolder\Filename.PDF). I want to give this path to IFrame like  <iframe id="imgdisplay" src="" runat="server"> Mostly Browser Compatibility Issues for IFrame ,see below 1. In IE Browser, If we call this path in iframe src it will displays the PDF file. Ex: imgdispla...
Read more

Delete Empty Rows or Null Rows in Datatable in C#

-
How to Delete Empty Rows or Null Rows in Datatable Example:  In this application we can see how to Delete Empty Rows or Null Rows in Datatable. Mostly this issue comes from while uploading the excel(.xls,.xlsx) file data into your sql table through datatable in windows application or web application. In rare cases,we can see while getting data from excel to datatable it will copies the empty rows also. Below Code. C# public DataTable DeleteEmptyRowsFromDataTable(DataTable dt) { for (int i = dt.Rows.Count - 1; i >= 0; i--) { if (dt.Rows[i][1] == DBNull.Value) dt.Rows[i].Delete(); } dt.AcceptChanges(); return dt; }
Read more

Angular Code Optimization Techniques and Methods

-
Angular code optimization refers to the process of improving the performance of an Angular application by reducing the amount of time it takes to load and run the application. This includes reducing the size of the code, minimizing the number of requests to the server, and improving the rendering speed of the application. Code optimization techniques for Angular can include strategies such as using lazy loading, AOT (Ahead-of-Time) compilation, using OnPush change detection strategy, and optimizing the use of pipes, observables, and other directives. The goal of code optimization is to create a faster, more efficient application that provides a better user experience for the end-users. By optimizing the code, the application can load faster, run smoother, and use less resources, which can improve its overall performance and user satisfaction. Here are some tips to optimize Angular code: Use OnPush Change Detection Strategy : This strategy only checks for changes when the @Input propert...
Read more