![\"Cyber](\"/eccb15472031c29e474058c5e8f0e586/Cyber-risk-for-CMOs-CIOs-and-CISOs.webp\")
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.
\nToday, 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).
\nBut 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.
\nSo, 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).
\nAn example is how these C-suite professionals are treating identity as a shared cornerstone that keeps consumers engaged and vulnerabilities under control.
\nA 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.
\nCIAM 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.
\nThe C-suite security, information, and marketing leaders advocate CIAM platforms that are seamless and consistent across multiple devices and touchpoints.
\nA few other features they look for include:
\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.
\nNow, there is a shift in executives and board directors' mindset. They perceive cybersecurity as a vital element of enterprises' business strategies.
\nWhen a cybercrime happens, it takes away much more than just consumer data. From finances to brand reputation, everything is at stake.
\nTherefore, cybersecurity is a critical problem for the boardroom, and every organizational stakeholder is focusing their attention on it.
\nIt 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![\"Enterprise](\"/860c267222fd012ab48fe9e6c26d0129/EB-The-Enterprise-Buyer%E2%80%99s-Guide-to-Consumer-Identity.webp\")
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.
\nWith such diverse job roles, consumer identity management can still meet the CIO, CMO, CISO's goals. Wondering how? Here are five ways:
\nAs the new \"work from anywhere\" situation continues to intensify, consumers and employees are becoming the new parameters for security.
\nA 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.
\nWith the regulatory landscape becoming denser than ever, consumers are particular about their data sharing and preference protocols.
\nConsumer 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.
\nCybercriminals 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.
\nA 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.
\nAnother crucial implementation that CIOs, CMOs, and CISOs agree upon is the need for consistent availability and up to zero downtime.
\nA 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.
\nGood 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.
\nFor 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](\"/b438f56ed00e165b0f1e9b7cba5b1845/LoginRadius-Identity-management-for-CIO-CISO-and-CMO.webp\")
LoginRadius is a comprehensive, streamlined consumer identity management solution that helps stakeholders of large enterprises to drive automation, authentication, effective compliance, among other requirements.
\nThe consumer identity management platform lets CIOs, CISOs, and CMOs to manage identities on-the-go while operating complex ecosystems. Some of the features include:
\nA unified view of each consumer: LoginRadius offers a single view of each consumer with the data gathered from all services and website touchpoints. This data comes handy while monitoring consumer journeys across diverse applications and services.
\nCMOs and their team can create marketing personas that reflect consumers and entice them with special offers.
\nAdvanced options for login: The consumer identity management platform offers a plethora of new and advanced login options to help enterprises gain a competitive advantage over others.
\nExamples include passwordless login that replaces password with a one-time link and smart login that delegates the authentication process to other devices.
\nIt also offers social login that allows consumers to authenticate via their social accounts. In fact, it is one of the most common and seamless ways of letting consumers access enterprises' services.
\nOptimized data collection: As consumers become more cautious about sharing their data, enterprises can leverage the LoginRadius CIAM platform to seamlessly collect information about them.
\nAn 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.
\nFor 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).
\nSecurity 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.
\nOther compliances include the CCPA and the GDPR for enterprises to meet consumer preference and location-specific regulations, wherever they do business.
\nConsumer 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![\"book-free-demo-loginradius\"](\"/8fce571f703a5970dbb1359a2fe0e51a/book-a-demo-loginradius.webp\")
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.
\nThis blog will cover the basic use of maps in Go, and how a newcomer to the language may utilize them for their applications.
\nMaps (also called dictionaries) are a very useful tool in helping to store and organize objects to be accessed in an efficient method.
\nMost 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![\"Dictionary\"](\"/e4a5b4578afa0881d70c2574866850f7/dictionary.webp\")
Initialization of a map can be done using the make command. This is similar to the initialization of a slice:
mapObject := make(map[string]string)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.
Examples of valid key types include booleans, numbers, strings and several other primitives can be used as keys.
\nOne more thing to note is that structs can be used as a key, provided that all the properties of the struct are Comparable.
Maps can also be created using a map literal. For an empty map:
\nmapObject := map[string]string{}Or for a map with initial data:
\nmapObject := map[string]string{\n\t“Key1”: “Value1”,\n\t“Key2”: “Value2”,\n\t“Key3”: “Value3”,\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:
\nmapObject[“test”] = “test_value”![\"Fetching\"](\"/c529fc135c0b7780aaed9d5e7b1325b1/fetching.webp\")
Retrieving a value uses the same format.
\nresult := mapObject[“test”]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.
A boolean that returns the key’s existence can also be returned if two arguments are assigned from the retrieval. For example:
\nresult, exists := mapObject[“test”]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.
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:
delete(mapObject, "test")The delete method does not have a return value, so if the key does not exist in the map, nothing will happen.\nLength
\nThe number of key-value pairs of a map can be found using the len method:
\nlength := len(mapObject)Using Go’s range keyword, a map can be iterated through.
\nfor key, value := range m {\n fmt.Println("Key:", key, "Value:", value)\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.
\nAlthough 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.
\nTo 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.
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.
\nAlthough 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.
\nIf 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/6caba3d40f8e06af28c2d45a8fbd6ea7/58556/index.webp","srcSet":"/static/6caba3d40f8e06af28c2d45a8fbd6ea7/61e93/index.webp 200w,\n/static/6caba3d40f8e06af28c2d45a8fbd6ea7/1f5c5/index.webp 400w,\n/static/6caba3d40f8e06af28c2d45a8fbd6ea7/58556/index.webp 800w,\n/static/6caba3d40f8e06af28c2d45a8fbd6ea7/99238/index.webp 1200w,\n/static/6caba3d40f8e06af28c2d45a8fbd6ea7/90fb1/index.webp 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":"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\nTo get LoginRadius swags see our Hacktoberfest Launch Blog. We have around 500 swags for our open source contributors.
\n
Here is a list of our open source projects available on Github for hacktoberfest 2020
\n![\"loginradius-hacktoberfest\"](\"/02fcd3f81a4a4130403e1ae6713b83f8/lr-open-source.webp\")
LoginRadius Engineering Portal
\nCascade
\n\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/9a2056972f92077b2af8b32ecc2fcbdd/58556/hacktober-fest-banner.webp","srcSet":"/static/9a2056972f92077b2af8b32ecc2fcbdd/61e93/hacktober-fest-banner.webp 200w,\n/static/9a2056972f92077b2af8b32ecc2fcbdd/1f5c5/hacktober-fest-banner.webp 400w,\n/static/9a2056972f92077b2af8b32ecc2fcbdd/58556/hacktober-fest-banner.webp 800w,\n/static/9a2056972f92077b2af8b32ecc2fcbdd/e30b5/hacktober-fest-banner.webp 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":"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
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.
\nA 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).
\nJWTs are most commonly signed using one of two algorithms: HS256 (HMAC using SHA256), and RS256 (RSA using SHA256).
\nA 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).
\nIn 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.
\nHS256 is a symmetric signing method. This means that the same secret key is used to both create and verify the signature.
\nThe 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.
\nAside 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.
\nRS256 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.
\nThe 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.
\nThe 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.
\nBoth signing schemes are effectively secure, with HS256 being a little faster. However, given this use case, the difference in speed is not particularly relevant.
\nThe main consideration on which to use, is in my opinion the symmetric vs asymmetric property of each:
\nHaving 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.
\nHaving 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/2fd4c7f86c996d936d9b217235d6257d/58556/unsplash.webp","srcSet":"/static/2fd4c7f86c996d936d9b217235d6257d/61e93/unsplash.webp 200w,\n/static/2fd4c7f86c996d936d9b217235d6257d/1f5c5/unsplash.webp 400w,\n/static/2fd4c7f86c996d936d9b217235d6257d/58556/unsplash.webp 800w,\n/static/2fd4c7f86c996d936d9b217235d6257d/99238/unsplash.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Nick Chim","github":"nickc95","avatar":null}}}},{"node":{"excerpt":"Rendering is an essential procedure a programmer has to manage in frontend development. In React, the render() method is the only required…","fields":{"slug":"/engineering/understanding-react-rendering/"},"html":"Rendering is an essential procedure a programmer has to manage in frontend development. In React, the render() method is the only required method in a class component and is responsible for describing the view to be rendered to the browser window. Coupled with the clever way React operates around its virtual DOM concept, there are certain subtleties in how this method works. Understanding them will greatly benefit any aspiring React developer.
\nThroughout this writing, I will reference this codepen for a demonstration of discussed behaviors.
\nrender() 101First of all, render() is not user callable. It is part of the React component lifecycle. Generally, it gets called by React at various app stages when the React component instantiates for the first time, or when there is a new update to the component state. Render does not take any arguments and returns a JSX.Element which contains the view hierarchy of the current component. This view hierarchy will later be translated into HTML and displayed in the browser window.
As mentioned before, render() is not user callable as it is an event that happens in the component’s lifecycle. With that said, if it is absolutely necessary to render the view manually, you can instead call the built-in class method forceUpdate(). Keep in mind that this is considered an anti-pattern. If you were designing sensible React components, its state and props changes should naturally control the render process, and you should never feel the need to make a manual call.
Within the lifecycle, these are the scenarios where render is called:
\nconstructor() call.setState() callIf you have the Codepen opened at this point, before anything is rendered you will see 2 alert messages from the browser: \"render() is called in Parent component!\", and \"render() is called in Child component!\". These messages are invoked from the corresponding render() methods of the example's parent and child component. They serve to introduce the first case of render() invocation: when the component is first instantiated.
Once the set of alerts is dismissed, a very simple UI will render:
\n![\"Example](\"/86a7253364a0299e9ca03339073fecfb/image1.webp\")
The dotted border line distinguishes between elements that belong to the Child component of the example (inside the dotted line) versus the Parent component.
\nchildElementText state of the Parent component, which in turns updates the text prop of the Child component, triggering a render in both Parent and Child. onChildPropChange = () => {\n this.setState({\n childElementText: "I am the child element! I am updated following a prop change."\n })\n }helloWorldMessage state within Child component, triggering a render following a state change. onTextChange = () => {\n this.setState({\n helloWorldMessage: "Hello React! (state change after setState call)"\n })\n }A visual and interactive reference to the React lifecycle can be found here.
\nIt is worth noting that following a props update or setState(), the method shouldComponentUpdate() is invoked to determine whether render() should be called. By default, this method always returns true. But it can be overloaded to implement custom logic. It is the actual way to define custom render behavior in each React component.
The shouldComponentUpdate() provides you with nextProp and nextState as arguments, which allows you to compare the current state and props of the component. For example, this code block will invoke render() only when the text prop changes:
shouldComponentUpdate(nextProps: NewComponentProps, nextState: NewComponentState) {\n if (this.props.text !== nextProps.text) {\n return true;\n } else {\n return false;\n }\n }The characteristics and behaviors mentioned above made it imperative that render() is a pure function. That means inside render(), you should not make an update to the component's states or props (no setState() call nor Redux state update). This makes sense because an update to the component will then trigger a new render() call, which can potentially lock you into an infinite render loop.
In terms of return value: render() returns a single JSX element, as mentioned above. This comes with certain implications:
<div>, or a <React.Fragment>. It is worth noting that once rendered, <React.Fragment> will vanish from the DOM structure. It is only meant to be a wrapper component and does not appear in the final DOM in the browser. This makes it a more sensible choice over a <div> wrapping to avoid nesting div’s.render() method, it is helpful to think about how the entire UI will look like at a moment in time, instead of thinking about how a certain element updates over time. “Thinking about how the UI should look at any given moment, rather than how to change it over time, eliminates a whole class of bugs.”key propThe render() method in each React component then feeds into what is called the Reconciliation Algorithm. This is the primary algorithm that dictates how React renders the real DOM in your browser based on a virtual DOM maintained internally by React. To intelligently determine what needs to be rendered on every call, React compares the current state of the virtual DOM and the real one and only makes changes to the physical DOM where it recognizes that the UI has been updated.
While not every single detail is known about React’s reconciliation algorithm, the characteristics detailed in the official documentation are enough for us to start phasing out certain suboptimal rendering patterns, thus writing a more robust render() method.
For instance, given this DOM subtree:
\n<div>\n <span key="li-1">list item 1</span>\n\n <span key="li-2">list item 2</span>\n\n <span key="li-3">list item 3</span>\n</div>If a <NewComponent> is then added to the top of the list:
<div>\n <!-- previously <span>list item 1</span> - element is detached and <NewComponent /> instantiated -->\n <NewComponent />\n\n <!-- previously <span>list item 2</span> - content will be updated to "list item 1" -->\n <span>list item 1</span>\n\n <!-- previously <span>list item 3</span> - content will be updated to "list item 2" -->\n <span>list item 2</span>\n\n <!-- new <span>list item 3</span> is element created -->\n <span>list item 3</span>\n</div>If instead <NewComponent> is added to the bottom:
<div>\n <!-- previously <span>list item 1</span> - no change -->\n <span>list item 1</span>\n\n <!-- previously <span>list item 2</span> - no change -->\n <span>list item 2</span>\n\n <!-- previously <span>list item 3</span> - no change -->\n <span>list item 3</span>\n\n <!-- new instance of <NewComponent /> is added -->\n <NewComponent />\n</div> In the example above, appending <NewComponent> to the end of the list will result in 1 new instantiation, versus 1 instantiation, 3 updates and 1 tear down. In a larger application scale, this will prove to be a significant performance difference in the long run.
If you have ever tried to use the map() method to iterate over an array to render a list of elements, it is likely that you have seen React complaining about a missing key prop to each rendered list item. So what does the key actually do?
A key is React’s way to recognize elements in the DOM tree, comes reconciliation time. When React is parsing all children of an element, it can leverage keys to match elements that were present from the last update. That allows you to shuffle the order of child elements without interfering with the algorithm. As long as the key matches between updates, React will preserve the element configuration.
Coming back to the example above, let’s add keys to all the existing list items:
\n<div>\n <span key="li-1">list item 1</span>\n\n <span key="li-2">list item 2</span>\n\n <span key="li-3">list item 3</span>\n</div>In this case, if we were to add an extra “list item 4” at the top of the list, it would not come with the same performance penalty:
\n<div>\n <!-- new item - <span> is instantiated -->\n <span key="li-4">list item 4</span>\n\n <!-- matched with the old "li-1" key - element stays unchanged between renders -->\n <span key="li-1">list item 1</span>\n\n <!-- matched with the old "li-2" key - element stays unchanged between renders -->\n <span key="li-2">list item 2</span>\n\n <!-- matched with the old "li-3" key - element stays unchanged between renders -->\n <span key="li-3">list item 3</span>\n</div>In case a subtree is generated using a map() or other iterative methods, React requires that keys are provided with the element. However, even in case a DOM subtree is manually added, keys should be provided on subtrees that have complex behaviors regarding conditional rendering.
React is a clever framework that offers performance through its rendering scheme, so it follows that, as developers, we should leverage it appropriately to help build performant applications. With that said, it is not a miracle device that optimizes out inefficiencies from the developer’s end, but a tool to be utilized. Understanding the render() nd its implication to the reconciliation algorithm is the first step to make sure we are leveraging the framework instead of working against it. It is also one of the first steps to mastering React.
Ajax stands for Asynchronous Javascript and XML. Ajax is a programming technique that allows us to create dynamic, complex, and asynchronous web applications. Ajax allows us to send and receive data from the webserver asynchronously without interfering with the current state or behavior of the web page or application.
\nXHR is the XMLHttpRequest Object which interacts with the server. Ajax technique in the nutshell leverages the XHR request to send and receive data from the webserver. This object is provided by the browser’s javascript environment. It transfers the data between the web browser and server.
\n![\"Ajax](\"/1513d4dbffc972d8a7d67063cf7d9886/ajax.webp\")
Dynamic content modification of web page: Using Ajax reloading of a web page is not required. The content of a web page can be modified dynamically by calling the XHR request in the background and changing the content using DOM Modification.
\nTo send and receive data from the server and implement the Ajax simple steps are explained below:
\nvar xhrobj = new XMLHttpRequest();xhrobj.open('GET','example.com/get');\nxhrobj.send();| \n | \n |
|---|---|
| open(method, url[, async[, user[, password]]]) | \nIt initializes the request. | \n
method | \nrequest type such as GET,POST etc | \n
url | \nRequest URL | \n
Async | \ntrue or false | \n
user | \nUsername for basic authentication | \n
password | \nPassword for basic authentication | \n
| send(body) | \nIt sends the request to the server body : it is optional to send body of data with request. | \n
In case of sending POST request :
\n xhrobj.open("POST", 'example.com/post', true);\n xhrobj.setRequestHeader("Content-type", "application/x-www-form-urlencoded");\n xhrobj.send("username=john");| \n | \n |
|---|---|
setRequestHeader(header,value) | \nIt sets the header for the HTTP request. | \n
header | \nname of header parameter | \n
Value | \nvalue of the parameter | \n
On completion of the request, the server sends the response to the request.
\nxhrobj.onreadystatechange = function () {\n if (this.readyState == 4 && this.status == 200) {\n document.getElementById("response").innerHTML = xhrobj.responseText;\n }\n}| \n | \n |
|---|---|
onreadystatechange = callback() | \nIt is a EventHandler called when the readyState attribute changes. | \n
readyState attribute | \nIt is an attribute that returns the current state of XMLHttpRequest object | \n
status attribute | \nIt is an attribute that returns the status code to the HTTP XHR request. | \n
responseText attribute | \nIt is an attribute that returns the DOMstring response as the text. | \n
Implementing the Ajax technique by using the XHR in javascript instead of going with using other javascript library functions like jQuery.ajax has advantages as well. For example, it gives you the freedom to embed your application or script with other applications or platform even if the particular library is not used by other applications. Thus it also helps in code reusability.
\n","frontmatter":{"date":"September 22, 2020","updated_date":null,"description":"Learn the concept of AJAX and XHR in JavaScript, the benefits of AJAX, and how easy it is to implement the AJAX into our web application.","title":"Ajax and XHR using plain JS","tags":["XHR","JavaScript","AJAX"],"pinned":null,"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/c19cc11ae05c7a1224ef47b974bbf68f/58556/index.webp","srcSet":"/static/c19cc11ae05c7a1224ef47b974bbf68f/61e93/index.webp 200w,\n/static/c19cc11ae05c7a1224ef47b974bbf68f/1f5c5/index.webp 400w,\n/static/c19cc11ae05c7a1224ef47b974bbf68f/58556/index.webp 800w,\n/static/c19cc11ae05c7a1224ef47b974bbf68f/99238/index.webp 1200w,\n/static/c19cc11ae05c7a1224ef47b974bbf68f/135cd/index.webp 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Apeksha Gupta","github":"ApekshaAgarwal","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.
\nWe’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.
\nThe goal? Having them spend less time searching and more time building.
\nLoginRadius’ 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.
\nHere’s a closer look at what’s new and why it’s important:
\n![\"This](\"/f46881583c7518a93bb24e94c32320de/a-developer-friendly-dark-theme.webp\")
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.
\nThe 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.
\nSo, 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![\"This](\"/e5358b82be414940f3fb146013845933/capabilities.webp\")
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:
\nThis structured layout ensures you can quickly understand each capability and how it integrates into your identity ecosystem.
\n![\"This](\"/a8c155c2b6faf3d5f4b4de4e2b14d763/developers-menu.webp\")
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.
\nThe 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![\"This](\"/b2f9a964a2da0ea83e2f8596b833bba7/we-support-your-tech-stack.webp\")
Developers now have a clear view of the tech stack available with LoginRadius, designed to support diverse business needs.
\nOur platform offers pre-built SDKs for Node.js, Python, Java, and more, making CIAM integration seamless across popular programming languages and frameworks.
\nCheck out our revamped LoginRadius website and see how the improved experience makes it easier to build, scale, and secure your applications.
\nDo 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.webp"}}}},"pageContext":{"limit":6,"skip":726,"currentPage":122,"type":"///","numPages":164,"pinned":"ee8a4479-3471-53b1-bf62-d0d8dc3faaeb"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}