{"componentChunkName":"component---src-templates-blog-list-template-js","path":"/119","result":{"data":{"allMarkdownRemark":{"edges":[{"node":{"excerpt":"C# and the .NET CLR use exceptions to show that an error condition has arisen during program execution. C# programs are under constant…","fields":{"slug":"/engineering/exception-handling-in-csharp/"},"html":"

C# and the .NET CLR use exceptions to show that an error condition has arisen during program execution. C# programs are under constant threat of running into some sort of problem. As a program’s complexity grows, the probability that something odd would happen during its execution also gets higher.

\n

In this blog, we will go through the basics of Exception and Exception handling. We will also look at how we can achieve exception handling using try, catch, and finally blocks and how to create your own custom exceptions.

\n

Exception

\n

The errors which we are getting at the run time of the application is called an exception.

\n

If any exception is coming into our application then the application is abnormally terminated. The Application is not considered as a good application if any exception is coming and it is not handled.

\n

Every time when we are developing an application and it got successfully build without any errors. Then this happens

\n

\n \n \n

\n

For that, it is good practice to use exception handling.

\n

Common .NET Exceptions :

\n

Below are the common .NET exceptions which we can see on a regular basis of coding.

\n

System.NullReferenceException – Occurs when calling a method on a null object reference

\n

System.IndexOutOfRangeException – Occurs attempting to access an array element that does not exist

\n

System.IO.IOException – Used around many file I/O type operations

\n

System.OutOfMemoryException – Occurs when the app runs out of memory

\n

System.InvalidCastException – Occurs when you try to cast an object to a type that it can’t be cast to

\n

System.InvalidOperationException - Occurs when a method call is invalid for the object's current state

\n

System.ArgumentException - Occurs when one of the arguments provided to a method is not valid

\n

Exception Handling

\n

The process of handling any run time error is called exception handling. The exception handling is performed to maintain the normal flow of the application.

\n

In C# we can achieve this using the below techniques:

\n

Try,Catch & Finally blocks

\n

This is a very basic Exception handling technique in which try, catch, and finally, blocks are used.

\n

try block: In this block the code is written which may cause the exception. If any exception is thrown then the corresponding catch block is executed.

\n

catch block: In this block the exception is caught which means if an exception is thrown from the try block then we write the code to handle or log it.

\n

finally block: In this block we write the certain code which we want to execute if an exception is thrown or not. For example: disposing of an object or closing the database connection.

\n

Exception Handling after using try, catch blocks

\n

\n \n \n

\n

Note: Multiple finally blocks are not allowed. Also, the finally block cannot have the return, continue, or break keywords. It doesn't let control leave the finally block.

\n

In C#, both catch and finally blocks are optional. The try block can exist either with one or more catch blocks or a finally block or with both catch and finally blocks. The try block without a catch or finally block will give a compile-time error.

\n

If there is no exception occurred inside the try block, the control directly transfers to the finally block. We can say that the statements inside the finally block are executed always.

\n
try\n{\n// Code which can cause an exception.\n}\ncatch(Type x)\n{\n// Code for handling the exception\n}\nfinally\n{\n//Any cleanup code\n}
\n

Multiple Catch blocks

\n

We can use the multiple catch blocks when we are not sure which type of exception will be thrown by the code. So that will help to catch the multiple types of exceptions.

\n
try{\n// Code which can cause an exception.\n}\ncatch(ArithmeticException ex)\n{\n// Code for handling the exception\n}\ncatch(IndexOutOfRangeException ex)\n{\n// Code for handling the exception\n}\nfinally{\n//Any cleanup code\n}
\n

Catch multiple exceptions in the single catch block

\n

We can use the generic exception class as well to catch all types of exception in that case we have to write the catch block as below:

\n
try{\n// Code which can cause an exception.\n}\ncatch(Exception ex)\n{\n// Code for handling the exception\n}\nfinally{\n//Any cleanup code\n}
\n

Note: Multiple catch blocks with the same exception type are not allowed. A catch block with the base Exception type must be the last block.

\n

Exception Filters

\n

In C# 6.0 a new feature is introduced to handle the exception which is called the Exception Filters. This feature will allow you to handle more specific exceptions in catch blocks so that you can write the code specific to the exception condition.

\n

Like before C# 6.0 We had to catch any exception and handle it. Now in C# 6.0, we can handle the exception specific to the condition.

\n
try\n{\n// Code which can cause an exception.\n}\ncatch(Type x) when(\n    //some condition\n)\n{\n// Code for handling the exception\n}\ncatch(Type x) when (\n    //some condition\n)\n{\n \n}\nfinally\n{\n//Any cleanup code\n}\n
\n

Nested try-catch

\n

C# allows nested try-catch blocks. When using nested try-catch blocks, an exception will be caught in the first matching catch block that follows the try block where an exception occurred.

\n
static void Main(string[] args)\n{\n    int divider = 0;\n \n    try\n    {\n        try\n        {\n            var result = 1/divider;\n        }\n        catch(Exception ex)\n        {\n            Console.WriteLine("Inner catch block");\n        }\n    }\n    catch(Exception ex)\n    {\n        Console.WriteLine("Outer catch block");\n    }\n    \n}
\n

An inner catch block will be executed in the above example because it is the first catch block that handles all exception types.

\n

If there is not an inner catch block that matches with raised exception type, then the control will flow to the outer catch block until it finds an appropriate exception filter.

\n

Throw an Exception

\n

C# allows throwing an exception. The throw keyword is used for that purpose. One of the benefits of throwing an exception can be when a problem occurs in the middle of the complicated method execution because handling that situation in that complicated method would make that method even more complex. Then we should throw an exception and let the catch block to handle it.

\n

The throw keyword can only be used with the Exception object except for the catch block. It will be discussed in the next section.

\n
try\n{\n    //throw exception\n    throw new Exception();\n}\ncatch (Exception ex)\n{\n    //some code to hadle the exception\n}
\n

Note: The throw keyword is used to throw or create the new exception. If the throw keyword is used and if there is any catch block then the catch block will be executed next.

\n

Rethrow an Exception

\n

When an exception is caught in the catch block, we can do some operations and then re-throw the exception. Rethrow an exception means calling the throw keyword without an exception object inside a catch block.

\n

Here is the point to note that if we follow the below approach to rethrow the exception then the proper stack trace will not be maintained means it will not point out that actually where the exception occurred it will show in the stack trace the line number from which the exception is rethrown.

\n
try\n{\n    // Code which can cause an exception.\n}\ncatch (Exception ex)\n{\n    throw ex;//Exception is rethrown with the exception object\n}
\n

Now if we follow the below approach then the proper stack trace will be maintained with maintaining the exact line number where the exception actually occurred.

\n
try\n{\n    // Code which can cause an exception.\n}\ncatch (Exception ex)\n{\n    throw;//Exception is rethrown with the exception object\n}
\n

User-defined Exceptions

\n

User-defined exceptions are those exceptions that are not defined by the programming language. In C# we can create our own custom exceptions(User-defined exceptions)

\n

C# exceptions are defined as classes, just like any other C# object. All exceptions are inherited from a base System.Exception class. There are many common exceptions that you can use within your own code.

\n

Creating your own C# custom exceptions is helpful only when you are going to catch that specific type of exception and handle it differently.

\n
    class Program\n    {\n        static void Main(string[] args)\n        {\n            try\n            {\n                //throw user defined exception\n                throw new CustomException("Custom exception thrown");\n            }\n            catch (Exception ex)\n            {\n                Console.WriteLine("Exception caught here" + ex.ToString());\n            }\n        }\n    }\n    class CustomException : Exception\n    {\n        //User-defined exception which inherits base class Exception\n        public CustomException(string message)\n        {\n            Console.WriteLine("User defined exception");\n        }\n    }
\n

Exception Handling Best Practices

\n

Log Exception

\n

It is considered a good practice to log all the exception which are coming into our application. The main benefit of logging exceptions that we can know exactly what are the conditions on which the code is failing instead of asking from the user that what inputs he has provided we can log all the required information and use that data to solve the error.

\n

In many cases, we just ignore the catch block by writing nothing in it. There are some .NET libraries available for logging purposes like NLog, Serilog, etc.

\n

We can log exception into the catch block. Every exception is coming into our application is crucial as they are critical to finding the problems in the code.

\n
try\n{\n   //Some code\n}\ncatch (Exception ex)\n{\n   //Log Exception here!!!\n   Log.Error(ex); // log the inputs provided by the user or any specific condition\n}
\n

First Chance & Second Chance Exception

\n

The first chance exception is mainly designed for debugging purposes. Like whenever an exception occurs it first goes to the debugger giving the first chance to you and then to the program/application. If that exception is unhandled in the program/application then it gets back to the debugger giving a second chance to you to do something with your code before and after the application itself decides to do.

\n

It gives you visibility into every .NET exception being thrown.

\n

We can enable the first chance exception in the Visual Studio by going into the\nDebug > Windows > Exception Settings > check next to \"Common Language Runtime Exceptions\"

\n

You can also select the exceptions you want the debugger to break automatically in the above setting.

\n

Conclusion

\n

In this blog, we learned about the basics of Exception, Exception Handling, and some best practices of exception handling. Use of the exception handling with its best practices in the application will help the application to run smoother and without any bad user experience.

\n","frontmatter":{"date":"September 29, 2020","updated_date":null,"description":null,"title":"Exceptions and Exception Handling in C#","tags":["C#","Exception","Exception Handling",".NET","Exception Handling Best Practices"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5748031496062993,"src":"/static/b5a34dc9602000bd64f40c7d59f9d286/ee604/csharplogo.png","srcSet":"/static/b5a34dc9602000bd64f40c7d59f9d286/69585/csharplogo.png 200w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/497c6/csharplogo.png 400w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/ee604/csharplogo.png 800w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/f3583/csharplogo.png 1200w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/5707d/csharplogo.png 1600w,\n/static/b5a34dc9602000bd64f40c7d59f9d286/5c6e9/csharplogo.png 1650w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Hemant Manwani","github":"hemant404","avatar":null}}}},{"node":{"excerpt":"A lot has been written and talked about Unit Testing in the IT industry for the last couple of years. I have heard and discussed the same…","fields":{"slug":"/engineering/unit-testing/"},"html":"

A lot has been written and talked about Unit Testing in the IT industry for the last couple of years. I have heard and discussed the same over the previous 2.5 decades of my IT career.

\n

Even though a lot is talked about and is done in this field but still today, every company is struggling with this. But before we proceed with the above situation, let us first understand its importance.

\n

A strong foundation is the basis of a strong building in the same way a proper unit testing is the foundation of high-quality software.

\n

Unit Testing, if done correctly, ensures that each of the building blocks of the software product is robust and will make high-quality software when put together.

\n

Unit testing is an essential tool in any serious software developer's toolbox. However, writing a good unit test for a specific piece of code can often be very hard.

\n

Developers frequently believe that their struggles are triggered by a lack of essential testing expertise or hidden unit testing techniques after experiencing trouble testing their own or someone else's code.

\n

What is Unit Testing?

\n

Testing of the unit requires testing individual components of the programme or application software. The primary objective behind this is to verify that all the individual components function as expected.

\n

As the smallest possible part of the software that can be evaluated, a unit is known. It usually has a couple of inputs and a single output.

\n

Both testers and developers can isolate each module, detect and repair device defects at a very early stage of the life cycle of software development with this testing method (SDLC).

\n

Why Unit Testing is essential?

\n

By considering stubs, mock artifacts, drivers, and unit testing frameworks, this methodology effectively helps validate the consistency of a section of code.

\n

Because it is practiced at the initial testing level, this testing methodology ensures that the vulnerabilities are detected and corrected at the early stage of SDLC, even before they become costly for businesses to repair when they are later identified.

\n

The developers and testers can help save time with a suitable unit testing practice as bugs can be found early in the process as it is the initial testing step. Skipping or restricting the unit testing practice will adversely increase the defects, and repairing them later becomes difficult.

\n

Therefore before preparing for the integration testing, it is essential to practice unit testing at the initial stage of the software testing process.

\n

Why is it difficult to run a smooth unit testing procedure?

\n

Well, it is not that a developer loves to find bugs in his/her coded code. Still, when it comes to unit testing, they at times(most of the time) see it has an additional overhead on them, especially when one has to follow and stick to a lot of protocols, frameworks, and documentation, etc.

\n

Also, it is commonly misunderstood that finding issues is the QC team's problem. We have to code. In my view, it is incorrect thinking as Quality Software is standard or combines commitment from a company and it's the team.

\n

What are the benefits of Unit Testing?

\n

Here are a few benefits of unit testing:

\n

1. Agile process

\n

The most significant advantage of unit testing is this. You would need to make improvements to the old design and code when you add more functionality to any programme, which can be costly and risky. If you use the technique of unit testing, this will save a lot of time and can make the whole process much quicker and simpler.

\n

2. Enhance the Code Quality

\n

Unit testing increases code consistency dramatically. It allows designers to recognize the smallest faults present in the units before they go for integration testing.

\n

3. Fix Software Bugs

\n

At a very early point, unit testing helps detect all sorts of problems with the programme. Until going any further, software developers should then focus on those problems first.

\n

This is the primary benefit of this because no other program component is compromised as the issues are fixed at an early stage. This results in improved performance, decreased downtime, and lower costs that would otherwise occur due to the entire design process's stalling.

\n

4. Facilitates Change

\n

When you test each part of the program individually, refactoring the code or upgrading the device library becomes much simpler. If there are any issues, they are found early on, and it thus becomes much easier to make improvements to the system.

\n

Before it goes on to the next level, the accuracy of each unit is checked. This implies that until it's incorporated with other companies, the device is proven to be in good working order.

\n

5. Provides Documentation

\n

Unit verification considers the whole system's documentation. By reading each module's documentation, developers who want to learn about the features of a specific programme or framework will quickly learn about the device.

\n

It makes it possible for them to have a detailed understanding of the system and what each part does.

\n

6. Seamless Debugging

\n

To a great degree, unit testing will simplify the debugging process. If a particular test fails, it is essential to debug only the most recent improvements made to the code.

\n

7. Reduce Costs

\n

In the early stages, any problems or glitches in the system are detected by unit testing, and the cost of bug fixes is significantly reduced because of this. If these vulnerabilities are found later, so repairing them would be even more costly.

\n

How to do Unit Testing?

\n

It is important for the unit testers to get a step-by-step instructional document in order to practice unit testing with the manual testing process.

\n

However, automated unit testing is often chosen by most companies, taking into account the efforts necessary for manual testing.

\n
    \n
  1. Is my written code fulfilling the business requirement for which I have written the code?
    2. \n
  2. How many other application areas is my code impacting? Are the values passed from the new block causing an impact on existing areas? Here I would like to state that one has to focus more on the behavior of the existing code with new values. The earlier we do it in the coding cycle the better it is in terms of rework at the developer's end.
    3. \n
  3. If you can follow a specific framework like Junit or Nunit etc, for conducting the unit testing is fine, but if not, you are not able to do that it does not matter as I can always pass a set of values(both positive or negative) to my written code.
    4. \n
  4. If there is no Test case management tool for trapping the unit test values, do not worry; just make a .txt file, put the values, and outcomes in that and you can see the same on a shared drive.
    5. \n
  5. Can I write a few automated scripts to execute the repetitive code to save time?
    6. \n
  6. Can I show my code to my next neighboring coder to have a quick look into the same?
    7. \n
  7. If my code involves a UI can I have a quick run-through by a BA or PM or Tester from a usability point of view?
    8. \n
\n

In the end, remember that I am the first and the most basic foundation in a big building of Quality and have to always keep the same in mind whenever I code since no one is interested in buying a well-packaged product if its ingredients are not of high quality.

\n

By doing the above I am not only contributing to high-quality software but I can devote later high bug-fixing time to things like improving the performance/security of my code and avoiding going back to the drawing board for issues related to performance or security etc.

\n

Always remember in the software development unit testing serves as \"A stitch in time saves nine\".

\n","frontmatter":{"date":"September 29, 2020","updated_date":null,"description":"Unit testing is one of the types of software testing that requires an initial phase of testing. Find out the benefits and why its important for developers.","title":"Unit Testing: What is it and why do you need it?","tags":["Unit Testing","QA","Testing"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/35dc4816d23601e5b75a44da15e3d18c/14b42/unit-testing.jpg","srcSet":"/static/35dc4816d23601e5b75a44da15e3d18c/f836f/unit-testing.jpg 200w,\n/static/35dc4816d23601e5b75a44da15e3d18c/2244e/unit-testing.jpg 400w,\n/static/35dc4816d23601e5b75a44da15e3d18c/14b42/unit-testing.jpg 800w,\n/static/35dc4816d23601e5b75a44da15e3d18c/47498/unit-testing.jpg 1200w,\n/static/35dc4816d23601e5b75a44da15e3d18c/0e329/unit-testing.jpg 1600w,\n/static/35dc4816d23601e5b75a44da15e3d18c/947df/unit-testing.jpg 5472w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Sudhanshu Pandey","github":null,"avatar":null}}}},{"node":{"excerpt":"The role of consumer identity management in the business world is undeniable. In the past, identity was primarily used as a deciding factor…","fields":{"slug":"/identity/consumer-identity-management-cmo-ciso-cio/"},"html":"

The role of consumer identity management in the business world is undeniable. In the past, identity was primarily used as a deciding factor to authenticate transactions. If people were successful in verifying who they were, their transactions were approved.

\n

Today, identity is more than just about security. It drives businesses' trust, customer experience, emotional connection, and brand value. And, that's incredibly enticing to a Chief Marketing Officer (CMO).

\n

But many of the emerging applications of identity are also posing serious concerns with Chief Information Officers (CIOs) and CISOs. Remediating those threats could mean CMOs having to compromise with customer experience—something they have been working so hard to improve. 

\n

So, now the question arises. Can a CMO, CIO, and CISO work as a team when they crossroads? It turns out, they can (for the greater good of an enterprise).

\n

An example is how these C-suite professionals are treating identity as a shared cornerstone that keeps consumers engaged and vulnerabilities under control.

\n

Importance of Consumer IAM 

\n

A modern-day consumer identity management (CIAM) platform safely collects and maintains consumer identity and profile data, along with securing access to software, devices, and other services in the network. This is a reason why CMOs, CISOs, and CIOs of large enterprises see CIAM as a business enabler.

\n

CIAM is the solution that directly controls your experiences with consumers. Elements like registration, authentication, account management, consent and preference management, and consumer data security take the lead to the most extent.

\n

The C-suite security, information, and marketing leaders advocate CIAM platforms that are seamless and consistent across multiple devices and touchpoints.

\n

A few other features they look for include:

\n\n

Cyber Risk for CMOs CIOs and CISOs

\n

\n \n \n

\n

In the past, cyber risks were often viewed as highly technical. Earlier leaders used to perceive security threats as an IT issue, but that's not the case today.

\n

Now, there is a shift in executives and board directors' mindset. They perceive cybersecurity as a vital element of enterprises' business strategies. 

\n

When a cybercrime happens, it takes away much more than just consumer data. From finances to brand reputation, everything is at stake.

\n

Therefore, cybersecurity is a critical problem for the boardroom, and every organizational stakeholder is focusing their attention on it.

\n

It takes equal effort from CIOs, CSOs, and CISOs to mitigate the architectural complexities that cybercriminals prey on. To get a headstart, the security team can develop holistic frameworks that can be later adopted and extended across the board.

\n

\n \n \n

\n

How Consumer Identity Management meets CIO, CMO, CISO Goals

\n

While the CISO looks to find security loopholes in an enterprise, the CIO aims to implement new services and leverage benefits. The CMO is on the front line of dealing with brand value and consumer data.

\n

With such diverse job roles, consumer identity management can still meet the CIO, CMO, CISO's goals. Wondering how? Here are five ways:

\n

Enables secure access anywhere

\n

As the new \"work from anywhere\" situation continues to intensify, consumers and employees are becoming the new parameters for security.

\n

A consumer identity management platform adopts a holistic approach to help enterprises manage, monitor, and verify all users, accounts, or devices attempting to access the enterprises' infrastructure.

\n

Complies with privacy regulations

\n

With the regulatory landscape becoming denser than ever, consumers are particular about their data sharing and preference protocols.

\n

Consumer identity and access management have become a growing priority for security, information, and marketing leaders. They want their enterprises to be compliant with global regulations and enforces strict data sharing laws across multiple vendors, platforms, and channels.

\n

Prioritizes security risks and patches them 

\n

Cybercriminals can easily hack into enterprises because the latter aren't mostly competent in applying patches to known vulnerabilities. Board members and security executives should not only be responsible for identifying risks but also to reduce them.

\n

A CIAM platform helps these professionals prioritize risks and implement the right fixes with features like multi-factor authentication, passwordless login, single sign-on (SSO), and more. 

\n

Scalability and speed innovation

\n

Another crucial implementation that CIOs, CMOs, and CISOs agree upon is the need for consistent availability and up to zero downtime.

\n

A consumer identity management solution offers scalability that possibly demonstrates a frankly extreme degree. It is always ready for potential surges and dips in consumer activities.

\n

Improves consumer experience

\n

Good experiences call for happy consumers. A consumer identity management platform offers all the features to revolutionize consumer experience in every possible way. They also add up to more revenue and lower acquisition costs. 

\n

For instance, with a seamless login experience, CIAM encourages consumers to try all the enterprise's digital offerings. This way, consumers are more embedded in a digital space without extra effort. Other examples include the addition of advanced analytics, integration, unified consumer view, and more.

\n

LoginRadius Identity Management for CIO, CISO, and CMO

\n

\n \n\n

  • \n

    Optimized data collection: As consumers become more cautious about sharing their data, enterprises can leverage the LoginRadius CIAM platform to seamlessly collect information about them.

    \n

    An example of how it does is progressive profiling. The consumer identity management platform allows enterprises to collect consumer data from different touchpoints throughout the consumer journey. 

    \n

    For instance, they can start by building a basic profile with the details captured during login. Later, as they navigate the application, they can keep asking for more information (without making it compulsory).

    \n
    • \n
  • \n

    Security Compliance: The favorite feature of a CIO and CISO, LoginRadius, helps meet security compliance globally. The consumer identity management platform is certified by third-party security standards like AICPA SOC 2, ISAE 3000, Cloud Security Alliance, and Privacy Shield.

    \n

    Other compliances include the CCPA and the GDPR for enterprises to meet consumer preference and location-specific regulations, wherever they do business.

    \n
    • \n\n

    Conclusion

    \n

    Consumer behavior has never been static—nor have their expectations. A consumer identity management solution can be a strategic asset for CIOs, CISOs, and CMOs to use it to their advantage in their respective departments. Speaking of possibilities, they are endless here.

    \n

    \n \n \n

    \n","frontmatter":{"date":"September 28, 2020","updated_date":null,"description":"A modern-day consumer identity management (CIAM) platform securely collects and manages consumer identity and profile data, along with securing access to apps, computers, and other resources in the network.","title":"Consumer Identity Management for the CMO, CISO, and CIO","tags":["customer identity management","compliance","cx"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.408450704225352,"src":"/static/657c1ee5da6a3c3bfea422873a0ea96c/33aa5/image1.jpg","srcSet":"/static/657c1ee5da6a3c3bfea422873a0ea96c/f836f/image1.jpg 200w,\n/static/657c1ee5da6a3c3bfea422873a0ea96c/2244e/image1.jpg 400w,\n/static/657c1ee5da6a3c3bfea422873a0ea96c/33aa5/image1.jpg 768w","sizes":"(max-width: 768px) 100vw, 768px"}}},"author":{"id":"Rakesh Soni","github":"oyesoni","avatar":"rakesh-soni.jpg"}}}},{"node":{"excerpt":"Golang Maps is a compilation of unordered key-value pairs. It is commonly used because it offers simple searches and values with the aid of…","fields":{"slug":"/engineering/golang-maps/"},"html":"

    Golang Maps is a compilation of unordered key-value pairs. It is commonly used because it offers simple searches and values with the aid of keys that can be retrieved, modified or deleted. It is a reference to a table with a hash.

    \n

    This blog will cover the basic use of maps in Go, and how a newcomer to the language may utilize them for their applications.

    \n

    What is a Map?

    \n

    Maps (also called dictionaries) are a very useful tool in helping to store and organize objects to be accessed in an efficient method.

    \n

    Most basic implementations of a map involve using a key to access a value in the map, resulting in key-value pairs, in which one key is associated with a specific value in the map. Within Golang, maps follow this definition.

    \n

    \n \n \n

    \n

    How to create a map?

    \n

    Initialization of a map can be done using the make command. This is similar to the initialization of a slice:

    \n
    mapObject := make(map[string]string)
    \n

    In this case, mapObject is a map that uses strings as a key to map to another string. When creating a map, the key type must be a type that is Comparable, or more specifically types that can be compared using the == operator.

    \n

    Examples of valid key types include booleans, numbers, strings and several other primitives can be used as keys.

    \n

    One more thing to note is that structs can be used as a key, provided that all the properties of the struct are Comparable.

    \n

    Maps can also be created using a map literal. For an empty map:

    \n
    mapObject := map[string]string{}
    \n

    Or for a map with initial data:

    \n
    mapObject := map[string]string{\n\t“Key1”: “Value1”,\n\t“Key2”: “Value2”,\n\t“Key3”: “Value3”,\n}
    \n

    How to use Go Maps (with Examples)

    \n

    Setting

    \n

    Interaction with Go maps are similar to the dictionaries and maps of other languages. A simple way to return a value associated with the key is to use bracket notation. For example, to set a string value mapped to a string key:

    \n
    mapObject[“test”] = “test_value”
    \n

    Fetching

    \n

    \n \n \n

    \n

    Retrieving a value uses the same format.

    \n
    result := mapObject[“test”]
    \n

    The value of result will be the value assigned to “test” in the map. In the case where no key is found, the zero value of the type is returned instead. In this case, if there is no associated value with “test”, an empty string is returned.

    \n

    A boolean that returns the key’s existence can also be returned if two arguments are assigned from the retrieval. For example:

    \n
    result, exists := mapObject[“test”]
    \n

    If “test” exists in the map, result will be the value associated with “test” and exists will be true. If “test” does not exist, result will be an empty string and exists will be false. This is useful when the map being used contains zero-values to distinguish between existence or whether the value is just zero.

    \n

    Deleting

    \n

    Using Go’s built in delete method, key-value pairs can be deleted off the map. To delete the previous “test” key from the map, the following can be called:

    \n
    delete(mapObject, "test")
    \n

    The delete method does not have a return value, so if the key does not exist in the map, nothing will happen.\nLength

    \n

    The number of key-value pairs of a map can be found using the len method:

    \n
    length := len(mapObject)
    \n

    Iterating

    \n

    Using Go’s range keyword, a map can be iterated through.

    \n
    for key, value := range m {\n    fmt.Println("Key:", key, "Value:", value)\n}
    \n

    There is no specific order in which the map is iterated. If a specific order is needed, a slice or other data structure can be used to store or hold data which can then be sorted and iterated through.

    \n

    Concurrency

    \n

    Although Go has a lot of support for concurrency through the use of goroutines and channels, maps alone are not a reliable approach to handling data in a concurrent setting.

    \n

    To work with maps that support concurrency, a separate synchronization method should be used, like sync.RWMutex. Alternatively, an open source map package which implements the synchronizations can be used.

    \n

    Conclusion

    \n

    With the market space and number of applications being created by Go increasing, hopefully this blog will help touch onto the basics of one of the major structures in Go.

    \n

    Although it doesn’t support concurrency, maps in Go are still a useful tool in most applications developed in Go, to reliably access and manage data.

    \n

    If you want to learn more about golang here is a quick guide on, how to send email with golang. If you like what you read leave a comment or any question and will communicate further.

    \n","frontmatter":{"date":"September 25, 2020","updated_date":null,"description":"A map is a builtin sort used for storing key-value pairs. Find out more in this article on how Golang maps work and why to use them.","title":"Golang Maps - A Beginner’s Guide","tags":["Go","dictionaries","maps"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/30bb9b9901e76f3498d68913a0675ea9/ee604/index.png","srcSet":"/static/30bb9b9901e76f3498d68913a0675ea9/69585/index.png 200w,\n/static/30bb9b9901e76f3498d68913a0675ea9/497c6/index.png 400w,\n/static/30bb9b9901e76f3498d68913a0675ea9/ee604/index.png 800w,\n/static/30bb9b9901e76f3498d68913a0675ea9/f3583/index.png 1200w,\n/static/30bb9b9901e76f3498d68913a0675ea9/0dadc/index.png 1500w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Chris Yee","github":null,"avatar":null}}}},{"node":{"excerpt":"LoginRadius Open Source Projects Just 1 week left in hacktoberfest 2020 and being part of it, we at LoginRadius are all set with lots of our…","fields":{"slug":"/engineering/loginradius-opensource-repos-for-hacktoberfest-2020/"},"html":"

    LoginRadius Open Source Projects

    \n

    Just 1 week left in hacktoberfest 2020 and being part of it, we at LoginRadius are all set with lots of our projects going open source this year.

    \n
    \n

    To get LoginRadius swags see our Hacktoberfest Launch Blog. We have around 500 swags for our open source contributors.

    \n
    \n

    Here is a list of our open source projects available on Github for hacktoberfest 2020

    \n

    \n \n \n

    \n\n
    \n

    Check the open issues on each of the projects as well as Pull Request before creating a new one. Happy Coding!\nStay tuned for more updates from LoginRadius and don't forget to check our Hacktoberfest Page to get around 500 swags from LoginRadius.

    \n
    \n","frontmatter":{"date":"September 25, 2020","updated_date":null,"description":"Checkout LoginRadius Open Source Repositories where you can contribute for hackotberfest 2020","title":"LoginRadius Open Source For Hacktoberfest 2020","tags":["hacktoberfest","open-source","LoginRadius"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5873015873015872,"src":"/static/ccafb9d75be0248e67ee6c688fd6cee5/ee604/hacktober-fest-banner.png","srcSet":"/static/ccafb9d75be0248e67ee6c688fd6cee5/69585/hacktober-fest-banner.png 200w,\n/static/ccafb9d75be0248e67ee6c688fd6cee5/497c6/hacktober-fest-banner.png 400w,\n/static/ccafb9d75be0248e67ee6c688fd6cee5/ee604/hacktober-fest-banner.png 800w,\n/static/ccafb9d75be0248e67ee6c688fd6cee5/31987/hacktober-fest-banner.png 1000w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Hridayesh Sharma","github":"vyasriday","avatar":null}}}},{"node":{"excerpt":"JWT Signing Algorithms When JSON Web Tokens are created, they are typically signed by its issuer. This allows the recipient of the token to…","fields":{"slug":"/engineering/jwt-signing-algorithms/"},"html":"

    JWT Signing Algorithms

    \n

    When JSON Web Tokens are created, they are typically signed by its issuer. This allows the recipient of the token to validate that the token received contains all of the information encoded by the issuer unmodified and as intended.

    \n

    A signature is not to be mistaken for encryption! The fact that a JSON token is signed does not mean that the data enclosed is unreadable by third parties. All a signature does is ensure that the message is authentic, which it achieves by allowing the recipient to compare the data they’ve received with a trusted claim included in the data (the signature).

    \n

    JWTs are most commonly signed using one of two algorithms: HS256 (HMAC using SHA256), and RS256 (RSA using SHA256).

    \n

    How does a signature ensure authenticity?

    \n

    A signature can only be created by someone possessing a secret key, and the original payload. Signatures are generally formed by combining the data to be signed with a secret key, either by appending them together and hashing them (HS256), or by encrypting a representation of that data (a hash) using the secret key (RS256).

    \n

    In both signing algorithms, the data is formatted into an immutable representation in a way that a recipient can check that the creator of the signature was in possession of that particular secret key.

    \n

    HS256

    \n

    HS256 is a symmetric signing method. This means that the same secret key is used to both create and verify the signature.

    \n

    The issuer appends the JWT header and payload with the secret key, and hashes the result using SHA256, creating a signature. The recipient uses their copies of the secret key, JWT header and payload in the same way to reproduce the signature, checking to see if they match.

    \n

    Aside from some incredibly unlikely scenarios, the only way for these signatures to be consistent is if the JWT header, payload and secret shared between the two parties are identical.

    \n

    RS256

    \n

    RS256 is an asymmetric encryption method. This differs from a symmetric scheme in that rather than using a single secret key, a pair of seperate keys are used to encrypt and decrypt the data.

    \n

    The issuer generates a hash of the JWT header and payload using SHA256, and encrypts it using the RSA encryption algorithm, and their private key. The recipient uses their public key to decrypt the signature ciphertext, and then compares it to a hash they’ve reproduced using their copy of the JWT header and payload, checking for consistency.

    \n

    The only way that these resulting hashes are consistent is if the JWT header and payload shared between the two parties are identical, and the public key corresponds to the private key used to encrypt the hash.

    \n

    When to use which?

    \n

    Both signing schemes are effectively secure, with HS256 being a little faster. However, given this use case, the difference in speed is not particularly relevant.

    \n

    The main consideration on which to use, is in my opinion the symmetric vs asymmetric property of each:

    \n\n

    Having an unsecured publicly available key is useful in many cases. For example, it can be published openly on the internet as part of a metadata endpoint, allowing JWT configurators to automatically retrieve the key, making for a straightforward and automatic JWT setup. As such, RS256 may be more suitable for situations where data is exchanged between two independent parties.

    \n

    Having a shared secret key can however also be useful in some cases. For example, if the issuer and recipient were both managed by a single party, the two applications would be able to share configurations without having to manage two separate keys. As such, HS256 may be more suitable for situations where data is exchanged within a single party

    \n","frontmatter":{"date":"September 24, 2020","updated_date":null,"description":"Deciding between which signing algorithm to use.","title":"JWT Signing Algorithms","tags":["JWT","JSON Web Tokens"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/9bdbc02fd668c5c3166222b458455efb/ee604/unsplash.png","srcSet":"/static/9bdbc02fd668c5c3166222b458455efb/69585/unsplash.png 200w,\n/static/9bdbc02fd668c5c3166222b458455efb/497c6/unsplash.png 400w,\n/static/9bdbc02fd668c5c3166222b458455efb/ee604/unsplash.png 800w,\n/static/9bdbc02fd668c5c3166222b458455efb/f3583/unsplash.png 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Nick Chim","github":"nickc95","avatar":null}}}}]},"markdownRemark":{"excerpt":"Identity is evolving, and developers are at the forefront of this transformation. Every day brings a new learning—adapting to new standards…","fields":{"slug":"/identity/developer-first-identity-provider-loginradius/"},"html":"

    Identity is evolving, and developers are at the forefront of this transformation. Every day brings a new learning—adapting to new standards and refining approaches to building secure, seamless experiences.

    \n

    We’re here to support developers on that journey. We know how important simplicity, efficiency, and well-structured documentation are when working with identity and access management solutions. That’s why we’ve redesigned the LoginRadius website—to be faster, more intuitive, and developer-first in every way.

    \n

    The goal? Having them spend less time searching and more time building.

    \n

    What’s New and Improved on the LoginRadius Website?

    \n

    LoginRadius’ vision is to give developers a product that simplifies identity management so they can focus on building, deploying, and scaling their applications. To enhance this experience, we’ve spent the last few months redesigning our interface— making navigation more intuitive and reassuring that essential resources are easily accessible.

    \n

    Here’s a closer look at what’s new and why it’s important:

    \n

    A Developer-Friendly Dark Theme

    \n

    \"This

    \n

    Developers spend long hours working in dark-themed IDEs and terminals, so we’ve designed the LoginRadius experience to be developer-friendly and align with that preference.

    \n

    The new dark mode reduces eye strain, enhances readability, and provides a seamless transition between a coding environment and our platform. Our new design features a clean, modern aesthetic with a consistent color scheme and Barlow typography, ensuring better readability. High-quality graphics and icons are thoughtfully placed to enhance the content without adding visual clutter.

    \n

    So, whether you’re navigating our API docs or configuring authentication into your system, our improved interface will make those extended development hours more comfortable and efficient.

    \n

    Clear Categorization for LoginRadius Capabilities

    \n

    \"This

    \n

    We’ve restructured our website to provide a straightforward breakdown of our customer identity and access management platform capabilities, helping you quickly find what you need:

    \n\n

    This structured layout ensures you can quickly understand each capability and how it integrates into your identity ecosystem.

    \n

    Developer-First Navigation

    \n

    \"This

    \n

    We’ve been analyzing developer workflows to identify how you access key resources. That’s why we redesigned our navigation with one goal in mind: to reduce clicks and make essential resources readily available.

    \n

    The new LoginRadius structure puts APIs, SDKs, and integration guides right at the menu bar under the Developers dropdown so you can get started faster. Our Products, Solutions, and Customer Services are also clearly categorized, helping development teams quickly find the right tools and make informed decisions.

    \n

    Quick Understanding of Integration Benefits

    \n

    \"This

    \n

    Developers now have a clear view of the tech stack available with LoginRadius, designed to support diverse business needs.

    \n

    Our platform offers pre-built SDKs for Node.js, Python, Java, and more, making CIAM integration seamless across popular programming languages and frameworks.

    \n

    Over to You Now!

    \n

    Check out our revamped LoginRadius website and see how the improved experience makes it easier to build, scale, and secure your applications.

    \n

    Do not forget to explore the improved navigation and API documentation, and get started with our free trial today. We’re excited to see what you’ll build with LoginRadius!

    \n","frontmatter":{"date":"February 21, 2025","updated_date":null,"description":"LoginRadius’ vision is to give developers a product that simplifies identity management so they can focus on building, deploying, and scaling their applications. To enhance this experience, we’ve redesigned our website interface, making navigation more intuitive and reassuring that essential resources are easily accessible.","title":"Revamped & Ready: Introducing the New Developer-First LoginRadius Website","tags":["Developer tools","API","Identity Management","User Authentication"],"pinned":true,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7857142857142858,"src":"/static/80b4e4fbe176a10a327d273504607f32/58556/hero-section.webp","srcSet":"/static/80b4e4fbe176a10a327d273504607f32/61e93/hero-section.webp 200w,\n/static/80b4e4fbe176a10a327d273504607f32/1f5c5/hero-section.webp 400w,\n/static/80b4e4fbe176a10a327d273504607f32/58556/hero-section.webp 800w,\n/static/80b4e4fbe176a10a327d273504607f32/99238/hero-section.webp 1200w,\n/static/80b4e4fbe176a10a327d273504607f32/7c22d/hero-section.webp 1600w,\n/static/80b4e4fbe176a10a327d273504607f32/1258b/hero-section.webp 2732w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Rakesh Soni","github":"oyesoni","avatar":"rakesh-soni.jpg"}}}},"pageContext":{"limit":6,"skip":708,"currentPage":119,"type":"///","numPages":161,"pinned":"ee8a4479-3471-53b1-bf62-d0d8dc3faaeb"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}