A studio with a 30-year legacy, Monolith's games include Blood, No One Lives Forever, Tron 2.0, Condemned: Criminal Origins, and more recently its excellent Middle-earth tie-ins Shadow of Mordor and Shadow of War, which introduced the remarkable Nemesis System.

Following Monolith's shock closure, GOG is offering 90% off its 2005 shooter FEAR and accelerating the game's preservation to recognise its doomed developer's 'contribution to gaming' | PC Gamer

The Nemesis System, which Monolith Productions developed for 2014's Shadow of Mordor game, has effectively been shelved by Warner Bros Games.

Warner Bros Games closes three studios and cancels their upcoming Wonder Woman game in another brutal round of layoffs in the gaming industry | Popverse

Two scientists from Toho University and NASA’s Nexus for Exoplanet System Science ran computer simulations and found that Earth’s oxygen-rich atmosphere won’t

Farewell oxygen on Earth — this is the date scientists have set for when the air will no longer be breathable

Historically, only higher earners have hit this limit, but the Two-Pot System may encourage more contributions. Raising the cap would allow those who can afford to save more to do so, improving long-term financial security while reducing reliance on government support in retirement.”

Anticipating the 2025 National Budget: insights on retirement reform and economic impacts

Alpha Centauri is also moving towards us, and in some 28,000 years from now, it'll reach its closest point at a distance of a little over three light years away, raising the odds of an interstellar influx in the future, too.

Alpha Centauri Sending Stream of Objects Into Our Solar System, Scientists Propose

HOUSTON, February 13, 2025--Hewlett Packard Enterprise announces its first shipment of NVIDIA GB200 NVL72 with direct liquid cooling.

HPE Announces Shipment of Its First NVIDIA Grace Blackwell System

Learn how the CG can better help the Maritime Transport System address the cybersecurity threats faced by this critical infrastructure subsector.

GAO Report Tackles Coast Guard Cybersecurity Support for MTS

System

system

The Dark Systems Manual

ডার্ক সিস্টেম ম্যানুয়াল

Priručnik za mračne sisteme

Manual de sistemas oscuros

کتابچه راهنمای سیستم های تاریک

डार्क सिस्टम्स मैनुअल

ダークシステムマニュアル

Харанхуй системийн гарын авлага

De handleiding voor donkere systemen

Mwongozo wa Mifumo ya Giza

தி டார்க் சிஸ்டம்ஸ் கையேடு

Buku ya Tisisiteme ta Munyama

Imanuwali Yezinhlelo Ezimnyama

In Āut's envisioned world, human capital is transformed into a quantifiable unit: Real-World Asset (RWA). Participation Score and Global Reputation are the leading concepts of this single system that frame individual worth in hard metrics rather than subjective qualities. Such a system would be able to quantify a person's many contributions, capabilities, and even moral merit. What would it mean if the value in humanity, long insulated from the market, became something like creditworthiness - defined, tracked, and traded like any other asset? Would we be cogs in the machine of dehumanization, or would this system lead us to perhaps a rediscovery of human interdependence, a throwback to the early origins of the community? My essay considers two possible futures enabled by measuring human capital over systemized humanity that constitutes a dystopian nightmare and a bucolic return to community-based values. The Dystopian Future: Humanity as Currency And now, imagine every interaction, each decision, and all actions being reduced to a point on a digital ledger. The Participation Score becomes another critical vital statistic, like blood pressure or oxygen level - but this rating dictates access to resources, freedom, and social mobility. Here, the ideal citizen is no longer just a productive worker but also a well-behaved node on the network. Fail to keep a good score, and your life becomes miserable. High scorers get premium housing, access to the latest medical advancements, and can travel wherever they want; low scorers are forced into low-skilled jobs, have no access to healthcare, and will be marginalized from the mainstream. The Global Reputation score further refines this division into hypersegregated digital classes. Ironically, the dystopian mechanism of ranking and commodification of human beings would be oddly democratic because of their fairness. The metrics would be out in the open; they would be transparent and algorithmically generated - so who could complain? Aren't these scores just a numerical reflection, after all, of one's actual participation and value to society? But within that lies the darkness. Human value defined by a quantified measure denies characteristics that cannot be measured: empathy, vulnerability, even creativity, and things that cannot be standardized. In a world consumed with measurable contribution, where would the room be for quiet contemplation, unprofitable kindness, or rebellion? The people no doubt would toe the line of the system's logic by turning life into some sort of performative exercise. Individuality would dissolve in everyone's pursuit of the highest Participation Score at the cost of authentic expression. This might ultimately create a world devoid of all emotional substance, where even interpersonal interactions would be driven by "reputational algorithms." Friendships, marriages, and even family communications become mercantile relationships - a bundle of ledgers pitted against a person's score's potential gain or loss. Trust, which had once been allowed to grow organically, is outsourced to technology: only those who emerge as trustworthy from such calculations can gain entry into the sanctum sanctorum of society. This is a dystopia based not on overt oppression but on subtle control. People think they are playing the game by their own will, yet they do not realize how the game has already possessed them. This would be the last stage of a systematized society: a free-for-all society in which everyone can succeed - but only according to the terms set forth by the system. A Bucolic Vision: Reconnecting Through Measured Interdependence But what if this same system could revitalize very ancient human values: reliance on community, mutual aid, and interdependence? Human beings weren't valued before the industrialized economies arose for their individual wealth or status but for their contributions within a tight-knit group. The community was the currency. In a bucolic return to these values, Āut's system could be reframed to celebrate human interconnection rather than competition. The Participation Score would track not just productivity but also how much one contributes to the well-being of others. Think of it as a kind of communal barometer, one that raises the stock of those who give the most—through care, teaching, mentoring, or simply being a good neighbor. In the Global Reputation system, technology could make this a speech tradition of another kind, one in which personal reputation earned over time via lived relationships means more than any abstract qualification. A world in which technology amplifies this human warmth through reinforcement of reasons to trust and cooperate. Trust becomes less transactional; instead, it's validated through the organic accumulation of positive interactions across many dimensions. In such a future, there would be a network where the measure of human capital is depth, not height. Here, instead of striving for the highest score, people may cultivate durable, mutual relations. Families and communities would flourish, governed by an integral measure of well-being, not by material success only. Social relations became the new currency. It is among ancient humans that societies were built up, earned trust, and kept through action rather than assigned by the algorithm. Systematization would reposition the value of human capital as a catalyst for community revival. No longer would it be solely a personal asset to be hoarded and displayed, but rather a communal resource that weaves people into the social fabric. By systematically rewarding collaboration, the Participation Score could spur people to care for each other and turn personal success into community well-being. Conclusion: The System as a Double-Edged Sword The systemization of human capital cuts both ways: On the one hand, it threatens to strip away the most treasured hallmarks of humanity—creativity, kindness, and autonomy. It reduces the individual to a series of quantified data points. On another, it may be a way to strengthen communities through participation and reputation-building, not in service of control, but to foster trust and cooperation. Āut's system of human capital as RWA is something that, in some way, computes what tech will do: to either conjoin more or break loose bonds between us. It begs the following questions about values: are we better off measured, ranked, and optimized? Or, do we come into our own when free from over-systemization and left to our relationships and communities as we did millennia ago? In Āut's envisioned world, human capital is transformed into a quantifiable unit: Real-World Asset (RWA). Participation Score and Global Reputation are the leading concepts of this single system that frame individual worth in hard metrics rather than subjective qualities. Such a system would be able to quantify a person's many contributions, capabilities, and even moral merit. What would it mean if the value in humanity, long insulated from the market, became something like creditworthiness - defined, tracked, and traded like any other asset? Would we be cogs in the machine of dehumanization, or would this system lead us to perhaps a rediscovery of human interdependence, a throwback to the early origins of the community? My essay considers two possible futures enabled by measuring human capital over systemized humanity that constitutes a dystopian nightmare and a bucolic return to community-based values. The Dystopian Future: Humanity as Currency And now, imagine every interaction, each decision, and all actions being reduced to a point on a digital ledger. The Participation Score becomes another critical vital statistic, like blood pressure or oxygen level - but this rating dictates access to resources, freedom, and social mobility. Here, the ideal citizen is no longer just a productive worker but also a well-behaved node on the network. Fail to keep a good score, and your life becomes miserable. High scorers get premium housing, access to the latest medical advancements, and can travel wherever they want; low scorers are forced into low-skilled jobs, have no access to healthcare, and will be marginalized from the mainstream. The Global Reputation score further refines this division into hypersegregated digital classes. Ironically, the dystopian mechanism of ranking and commodification of human beings would be oddly democratic because of their fairness. The metrics would be out in the open; they would be transparent and algorithmically generated - so who could complain? Aren't these scores just a numerical reflection, after all, of one's actual participation and value to society? But within that lies the darkness. Human value defined by a quantified measure denies characteristics that cannot be measured: empathy, vulnerability, even creativity, and things that cannot be standardized. In a world consumed with measurable contribution, where would the room be for quiet contemplation, unprofitable kindness, or rebellion? The people no doubt would toe the line of the system's logic by turning life into some sort of performative exercise. Individuality would dissolve in everyone's pursuit of the highest Participation Score at the cost of authentic expression. This might ultimately create a world devoid of all emotional substance, where even interpersonal interactions would be driven by "reputational algorithms." Friendships, marriages, and even family communications become mercantile relationships - a bundle of ledgers pitted against a person's score's potential gain or loss. Trust, which had once been allowed to grow organically, is outsourced to technology: only those who emerge as trustworthy from such calculations can gain entry into the sanctum sanctorum of society. This is a dystopia based not on overt oppression but on subtle control. People think they are playing the game by their own will, yet they do not realize how the game has already possessed them. This would be the last stage of a systematized society: a free-for-all society in which everyone can succeed - but only according to the terms set forth by the system. A Bucolic Vision: Reconnecting Through Measured Interdependence But what if this same system could revitalize very ancient human values: reliance on community, mutual aid, and interdependence? Human beings weren't valued before the industrialized economies arose for their individual wealth or status but for their contributions within a tight-knit group. The community was the currency. In a bucolic return to these values, Āut's system could be reframed to celebrate human interconnection rather than competition. The Participation Score would track not just productivity but also how much one contributes to the well-being of others. Think of it as a kind of communal barometer, one that raises the stock of those who give the most—through care, teaching, mentoring, or simply being a good neighbor. In the Global Reputation system, technology could make this a speech tradition of another kind, one in which personal reputation earned over time via lived relationships means more than any abstract qualification. A world in which technology amplifies this human warmth through reinforcement of reasons to trust and cooperate. Trust becomes less transactional; instead, it's validated through the organic accumulation of positive interactions across many dimensions. In such a future, there would be a network where the measure of human capital is depth, not height. Here, instead of striving for the highest score, people may cultivate durable, mutual relations. Families and communities would flourish, governed by an integral measure of well-being, not by material success only. Social relations became the new currency. It is among ancient humans that societies were built up, earned trust, and kept through action rather than assigned by the algorithm. Systematization would reposition the value of human capital as a catalyst for community revival. No longer would it be solely a personal asset to be hoarded and displayed, but rather a communal resource that weaves people into the social fabric. By systematically rewarding collaboration, the Participation Score could spur people to care for each other and turn personal success into community well-being. Conclusion: The System as a Double-Edged Sword The systemization of human capital cuts both ways: On the one hand, it threatens to strip away the most treasured hallmarks of humanity—creativity, kindness, and autonomy. It reduces the individual to a series of quantified data points. On the one hand, it threatens to strip away the most treasured hallmarks of humanity—creativity, kindness, and autonomy. It reduces the individual to a series of quantified data points. On another, it may be a way to strengthen communities through participation and reputation-building, not in service of control, but to foster trust and cooperation. On another, it may be a way to strengthen communities through participation and reputation-building, not in service of control, but to foster trust and cooperation. Āut's system of human capital as RWA is something that, in some way, computes what tech will do: to either conjoin more or break loose bonds between us. It begs the following questions about values: are we better off measured, ranked, and optimized? Or, do we come into our own when free from over-systemization and left to our relationships and communities as we did millennia ago?

Systemization of Human Capital: A Path Between Dystopia and Bucolic Revival

I Opt Out: System, Governance, And Coordination Must Change Bacause of AI Echoes

Write About Coordination, Governance, or System in the Opt Out Contest, Win up to $6000 in Prizes

অপ্ট আউট প্রতিযোগিতায় সমন্বয়, শাসন, বা সিস্টেম সম্পর্কে লিখুন, পুরস্কারে $6000 পর্যন্ত জিতে নিন

Schreiben Sie im Opt-Out-Wettbewerb über Koordination, Governance oder System und gewinnen Sie Preise im Wert von bis zu 6.000 US-Dollar

Escriba sobre coordinación, gobernanza o sistema en el concurso de exclusión voluntaria y gane hasta $6000 en premios

Écrivez sur la coordination, la gouvernance ou le système dans le cadre du concours de désinscription et gagnez jusqu'à 6 000 $ en prix

ऑप्ट आउट प्रतियोगिता में समन्वय, शासन या प्रणाली के बारे में लिखें, 6000 डॉलर तक का पुरस्कार जीतें

オプトアウトコンテストでコーディネーション、ガバナンス、システムについて書いて、最大 6,000 ドルの賞金を獲得しましょう

Opt Out 콘테스트에서 조정, 거버넌스 또는 시스템에 대해 글을 쓰고 최대 $6000의 상금을 받으세요.

Escreva sobre coordenação, governança ou sistema no concurso de desativação e ganhe até US$ 6.000 em prêmios

Напишите о координации, управлении или системе в конкурсе отказа и выиграйте призы до 6000 долларов США.

Vazgeçme Yarışmasında Koordinasyon, Yönetişim veya Sistem Hakkında Yazın, 6000$'a Varan Ödül Kazanın

Viết về sự điều phối, quản trị hoặc hệ thống trong cuộc thi chọn không tham gia, giành giải thưởng lên tới $6000

在退出竞赛中撰写有关协调、治理或系统的文章，赢取高达 6000 美元的奖金

In this article, we are going to talk about a system for performing authentication and authorization securely. To start off with lets understand, what is the difference between Authentication and Authorization. is the process of proving, you are, who you say you are, when accessing an application. Authentication is the process of defining and enforcing access policies - that is, what you can do once you’re authenticated. Authorization In this article, we will see: Why Authentication and Authorization matter How Authentication works How Authorization works Authentication System Design Conclusion Why Authentication and Authorization matter? Lets say we are in a meeting, and you are the leading the conversation. To ask for updates/status for something to the right  person, you need to identify (ie ) the person. Even to share some sensitive data with a person, you need to  authenticate the person correctly. And that is where authentication  comes in. Authenticate Now say, in the same meeting, a few decisions needs to be made. So for that, people who have the right for taking those decisions should be  the one taking the call, we cant just allow everyone to do everything.  Obviously some people are not catered enough to make some decisions, and  some for sure will try to make the worst out of it. So that brings , that gives certain people the rights permissions for certain activities. Authorization How Authentication works? To authenticate a person, we can assign a unique phrase to each person, and given the person tells the phrase correctly and their name.  We can say that ok, we have identified the person. This is the usual  usernames and passwords approach. When the right credentials are given, a  system considers the identity valid and grants access. This is known as  1FA or (SFA). Single-factor authentication SFA is considered fairly insecure. Why? Because users are notoriously bad at keeping their login information secure. Multi-factor  authentication (MFA) is a more secure alternative that requires users to  prove their identity in more than one way. Some such ways are: Single-use PIN numbers / OTP Authentication apps run by secure 3rd party (ex. Google/Microsoft Authenticator) Biometrics Once authenticated, the person would keep performing actions freely on the application. And the application is expected to have the person  recognized throughout their journey without forgetting them. Ideally, it  would be too much to ask the user to provide the password everytime  they move to a different page, or they do some activity. So we need a  way to keep the user authenticated after they have entered their  credentials and they have been authenticated once. This is called . Session Management 2 ways to keep the user authenticated: : When a user logins to a website on a browser, the server creates a session for that user and assigns a sessionid. This sessionid is stored by the server for reference and is sent back to the user to be stored in a cookie in the browser. Now each time the user would make a request the browser will send the sessionid along with the request. Which will help in authenticating the request. And, thus, preserving authentication while the user is on the site. Session-based authentication : For this, the server creates a encrypted token which is sent to the user and is saved by the browser only, as HttpOnly Cookies. All required information such as the user information, permissions and expiry of the token are encrypted within the token. The token is sent along for calls to the server. The server simply decrypts the token with the secret key and verifies the user. This token is refreshed at intervals. Token-based authentication The main differences between these two approaches would be that token-based authn is , cause the token neednot be stored on the server side. But for  session-based authentication, the token are needed to be stored on the  server side as well, which makes it . Which brings up complications, when the system is scaled or the number of users grows. Stateless Stateful For token-based authentication, we mostly use JWTs (JSON Web Tokens). How Authorization works? Once the user is authenticated, we would still need to ensure they’re only allowed to access resources that they have permissions to access.  Unauthorized access to sensitive data can be a disaster. By the  principle of least priviledge, companies would usually set up access  policies such that by default you have access to what is required for  you absolutely. And then in progression to that you have additional  access. Common ways to segment access are: : Users are assigned to a certain group/role that comes with set permissions. Examples: admin, member, owner. Role-based Access Control (RBAC) : Dynamically determines access privileges during authorization based on policies and rules. Policies are based on user roles, job functions, and organizational requirements. Policy-based Access Control (PBAC) : Users are permitted access according to attributes like title, certification, training, and/or environmental factors like location. Attribute-based Access Control (ABAC) : Each user or entity has individual permissions that can be turned on or off, similar to installing a new app on your phone and deciding which permissions to grant (location services, contacts, etc.) Access Control Lists (ACLs) ACL is frequently used at granular level than either ABAC or RBAC - for example, to grant individual users access to a certain file. ABAC and RBAC are generally instituted as company-wide policies. Authentication System Design Requirements Lets first start with defining the of the system: Functional requirements : Allow users to register by providing necessary information. Registration : Authenticate users based on their credentials. Login : Efficiently manage user sessions to ensure security. Session Management : Provide a secure process for users to recover their passwords. Password Recovery : Define roles and permissions for different user types. Access Control : Maintain detailed logs of authentication events for auditing. Audit Trail : Ensure low latency and quick response times. Performance A few that we are not going to consider for the scope of this article are: Non-functional requirements : Implement a robust MFA system. Multi-Factor Authentication (MFA) : Prioritize data security through encryption, secure storage, and secure communication. Security : Design the system to handle a growing number of users and transactions. Scalability : Minimize system downtime and ensure high availability. Reliability : Develop an intuitive user interface for a seamless experience. Usability Capacity Estimation Traffic Estimation First lets start with . Assuming an average traffic of 100,000 per month.We are estimating a 100k user traffic per month. Which translates to 0.04 request per second. We would need to respond to each request within  500ms 90% of the time, ie we require a p90 latency of 500ms. Traffic Estimation assumed_traffic_per_month = 100000 #requests
assumed_traffic_per_day = assumed_traffic_per_month / 30
                        ~= 3350 (assuming on higher end; 3333.33 to be precise)
estimated_time_per_request = 500 #ms; P90 of 500ms
traffic_per_second = (assumed_traffic_per_month) / (30*24*60*60) 
                   = 0.04 :  500ms (maximal acceptable latency, immaterial of the load on the system) The average capacity 1 instance can take, based on our calculations  is approximately 35ms to serve a request, assuming there are no heavy  processing happening for the particular request. Service Level Objective (SLO) Lets generate two more using the above metrics. derived metrics : Acceptable backlog per instance : Maximum number of requests(load) that can be accepted by an instance, without compromising SLO. Capacity : Backlog per instance : Total number of requests (load) that flows into a unit/instance based on current traffic. Demand Thus, SLO = 500ms
approx_response_time_for_one_request = 35 #ms
capacity = SLO/approx_response_time_for_one_request
         = 500 / 35
         ~= 20

load_on_one_instance = 0.04
instances_available = 1
demand = traffic_per_second / instances_available
       = 0.04 With the demand and capacity available, lets calculate total number of instances required. total_units_required = demand / capacity
                     = 0.04 / 20
                     = 0.002
                     ~= 1 Thus, we would be easily be able to handle 100k requests per month,  with 0.04 requestsper second, with 1 instance. Where each unit can  handle 20 requests per second without compromising SLO. Storage Estimation We would ideally need to store the user details for each user for authentication and authorization access.  Assuming, 5kb /user monthly_new_users = 500
monthly_additional_storage = 500 * 5kb
                           = 2500kb 
                           ~= 2GB So every month, assuming we will onboard 500 new users, we will require 2GB more storage. Incase we would like to keep authentication logs. Each authentication request is expected to take 2kb to store. auth_request_size = 2kb #assumption
monthly_storage = monthly_visitors * auth_request_size
                = 100,000 * 2KB
                ~= 200MB Thus, each month we would require an additional of 200MB, assuming a monthly traffic of 100k. Database Design Now that we have the capacity estimation done. Lets create the schemas of the database required to support the functional requirements. Lets quickly go over the tables. We are using 6 tables. Users - To store all the user information Credentials - To store the access/refresh credentials once the user has been authorized. Passwords - To store the user encrypted user passwords. PasswordRequests - To store the password change requests that comes for a particular user. Sessions - To store when the user had an active session and when was their last activity. ActivityApproval - To store approval requests for a activity performed by a particular user, that would be verified by admin. High-Level Design for the Authentication System System Endpoints Endpoint Description /login Authenticate user credentials. /logout End user session and revoke authentication tokens. /register Create a new user. /update/:userId Update user information. /delete/:userId Delete a user account. /grant/:userId/:permission Grant specific permissions to a user. /revoke/:userId/:permission Revoke permissions from a user. /check/:userId/:resource Check user’s access to a specific resource. /create/:userId Create a new user session. /expire/:sessionId Expire a user session. /validate/:sessionId Validate an active user session. Requirements Fulfilment Now, with all the things in place lets see how we can complete all the requirements. Registration - When a new user visits our application. We need to store user details so we can authorize/identify  the user next time they visit. Requirement - When a new user visits the application, and enters user details along with their email and password. That will  get captured in the database. The user details will be stored in the  User table. And the password will be stored in the credentials table in  an encrypted form. Fulfilled Login - When an existing user visits our application. We need to identify the user so we can authorize/identify  their actions and show them data that belongs to them. Requirement - When an existing user visits the application, and enters their details, email and password. We hash the  password and match the hash against the hash stored for the user in the  Credentials Table. If it matches then we have been able to identify the  user successfully. Else they need to enter the correct password that  they entered while registering. This process is called . Fulfilled Authentication Session Management - When a user has authenticated themselves, by entering their user and password. We need to make sure  that they stay logged in as they perform their future actions / try to  see sensitive data, without having them re-entering their password again  and again. Requirement - When the user authenticates successfully. The Authentication server will share 2 tokens with the client. A and a . The access_token can have encrypted data with it and it has a short  expiry time cause of security reasons. Once the client has the  access_token, it sends the access_token back along with every request  which helps in authenticating the request. When the access_token  expires, the client has to ask for a new access_token using the  refresh_token provided. This helps in maintaining a session. Fulfilled access_token refresh_token Password Recovery - When a user forgets their password, they would need to be able to reset their password securely. Requirement - When the user forgets their password, they can submit their email address in the forgot password page, and we  will generate a one time code and send the link to their email. When the  user clicks on this link with the code and email address. We will  securely be able to identify that the password recovery request is  authentic. And provide the user to set their new password. And thus  being able to recover the password. Fulfilled Access Control - When a user performs a certain action, we need to make sure that the user is authenticated to perform that  action and only then allow the action to happen. Requirement - We will maintain a list of actions, lets say 1-12, for simplicity. For each user we will maintain the  authenticated actions for that user. So now lets say the user tries to  perform an action #id 4. We will check if the user has the permissions  to perform action 4. If yes, we will go ahead and complete the request.  Else we show that the request isnt successful cause of lack of  permissions. Fulfilled Audit Trail - Incase of a security incident, we should be able to have enough logs to look through and have a plausible  reason as to what might have happened / or any leads as to what might  have been a possible cause of it. Requirement - For such scenarios, we can keep logs for every authentication action that happens on the server. (a). For each login request, we will keep a log as to  when the authentication happened, from where, ips and other relevant  details. (b). For each password recovery request, we will keep a  log as to when it was initiated, from where, ips, whether the request  was complete and other relevant details.        (c). Additionally, we will keep logs around each time a  user is authorized / unauthorized for an action and by who. These logs in all, should be able to indicate what might  have happened incase trying to understand some scenario. Fulfilled Performance - Requirement for performance as discussed in capacity estimation section, is 0.04 requests/second and 100k requests per month. Requirement - We have already handled the requirement with enough servers in the capacity estimation section. Fulfilled Conclusion In this article, we started by understanding what is the difference between Authentication and Authorization. Next, we created a Authentication and Authorization System. That is safe, secure, delivers performance while catering to industry standards and meeting all the desired requirements. Going forward i might update certain parts of the article to make it stay relevant as well as to cover more information and insights in building such a system.

Designing Functional Authentication and Authorization Systems

কার্যকরী প্রমাণীকরণ এবং অনুমোদন সিস্টেম ডিজাইন করা

Entwurf funktionaler Authentifizierungs- und Autorisierungssysteme

Diseño de sistemas funcionales de autenticación y autorización

Conception de systèmes d'authentification et d'autorisation fonctionnels

कार्यात्मक प्रमाणीकरण और प्राधिकरण प्रणालियों का डिजाइन

機能的な認証および認可システムの設計

기능적 인증 및 권한 부여 시스템 설계

Projetando sistemas funcionais de autenticação e autorização

Проектирование функциональных систем аутентификации и авторизации

İşlevsel Kimlik Doğrulama ve Yetkilendirme Sistemlerinin Tasarlanması

Thiết kế hệ thống xác thực và ủy quyền chức năng

设计功能性身份验证和授权系统

In “ ”, I created a React application using the , quickly adding several components in order to provide an impressive user experience. Having Fun with the Lightning Design System for React Lightning Design Framework for React The image below demonstrates what I was able to create in less than an hour on a rainy Sunday afternoon: In this article, I’ll improve upon the approach I employed while waiting for data to be retrieved from my fictional service. The Spinner Is Great, But … The Lightning Design Framework for React provides several ways to communicate to the user that some action is still processing. I’ve always enjoyed the look and feel of the spinner and was glad to see it made available by the Salesforce Engineering team. In my case, I like to provide additional information to the user to communicate “why” the spinner is active. I mean, is the spinner active because the system is still retrieving data? Or has something unexpected happened, and now things are in a stuck state? Without providing context alongside the spinner, it is hard for the customer to know how long the spinner should … well, you know … spin. In the illustration above, you can see the “Getting Data, Please Wait …” text below the spinner. In my case, the expectation is that the spinner would only spin long enough to retrieve data. Since the out-of-the-box spinner does not include the option to display text, I ended up using the following code for the original design: {this.state.showSpinner &&
<div style={{marginTop: 10, position: 'relative', height: '5rem'}}>
  <Spinner
    size="small"
    variant="base"
    assistiveText={{label: 'Getting Data, Please Wait ...'}}
  />
</div>
}

{this.state.showSpinner &&
<div style={{marginTop: 10}}>Getting Data, Please Wait ... </div>
} The result code above included showing the spinner when the this.state.showSpinner property is true, but also required showing another <div> to contain the text message I wanted to communicate to the user. This works but requires two separate elements to be used every time the spinner needs to include text. I knew that there must be a better way. Diving into the Blueprints The Salesforce Engineering team not only provides the Lightning Design Framework for React, but they also expose the which drive the design of those components. Component blueprints are framework agnostic, accessible HTML and CSS—used to create components in conjunction with implementation guidelines. component blueprints With the spinner component, for example, the provides everything needed to create the spinner using basic HTML and CSS: blueprint <div class="demo-only demo-only_viewport" style="height:6rem;position:relative">
  <div role="status" class="slds-spinner slds-spinner_medium">
    <span class="slds-assistive-text">Loading</span>
    <div class="slds-spinner__dot-a"></div>
    <div class="slds-spinner__dot-b"></div>
  </div>
</div> Now, I can use this information to create a custom component from the core blueprint documentation. Creating a Custom Component For my use case, I would like to include a text message below the spinner while active in order to communicate information related to the spinner. In the section above, I found the spinner blueprint code I planned to use and decided to create a React component to group the objects together. Within IntelliJ, I created a new file called which contains the following information: SpinnerWithDescription.js function SpinnerWithDescription(props) {
    return (
        <div className="slds-m-top_medium">
            <div className="slds-align_absolute-center slds-p-top_medium">
                <Spinner size="small"
                         variant="base"
                         assistiveText={{ label: props.description }}
                         isInline={true}
                         hasContainer={false} />
            </div>
            <div>
                <p className="slds-text-font_monospace">{props.description}</p>
            </div>
        </div>
    );
}

export default SpinnerWithDescription; With my approach, the code from the original spinner component becomes part of the React component, along with a simple paragraph of text - providing the information I wish to display below the spinner. Now, to use this new component anywhere in my React application, I just need to include a single line of code: <SpinnerWithDescription description=”some message goes here”/> I can also pass the description from another value stored in the current state: <SpinnerWithDescription description={this.state.loadingMessage}/> With this approach, any updates needed to the component can be made once without impacting components using the shared logic. SpinnerWithDescription Along the Way, I Discovered Style While looking at the blueprints, I noticed the presence of style-focused classes, which include the “slds” prefix. Just like how the 1980’s retailer, , helped transform my personal style from jeans and t-shirts to fancy pants and skinny ties, the “slds” style classes quickly transformed my user experience into something classier. Chess King Instead of using items like ... style={{marginTop: 10}} ... I used the to employ the Salesforce style classes which were ready and available: margins style documentation slds-m-top_small Now I can avoid the tedious exercise of finding the right number of pixels for my margins and have a consistent user experience in my app, but leveraging classes with the “slds-m” prefix - which are focused on setting margins. Stop Hiding the Application Title In my original design, the alert component would appear above the application title, which was not an ideal user experience.  Using the “slds” style classes, title was refactored as shown below: <div className="slds-text-heading_large slds-p-top_xx-large">
    Some Music Service
</div> The “slds-p” prefix focuses on padding and the “top_xx-large” suffix provides an ideal amount of spacing to no longer hide any part of the application title when the alert component is being displayed. Changing the Spinner Font I also decided to use a mono-spaced font for the spinner text—also already available as part of the framework—by including the following class: slds-text-font_monospace My New Design With the new component and styling in place, this is how my updated React application looks in action: While the changes are subtle, there are no longer any special rules to communicate when using the spinner. This new custom component can even become an official component in the Lightning Design System for React by following the steps outlined . here Conclusion Starting in 2021, I have been trying to live by the following mission statement, which I feel can apply to any IT professional: “Focus your time on delivering features/functionality which extends the value of your intellectual property. Leverage frameworks, products, and services for everything else.” - J. Vester In this article, not only did I leverage the existing Lightning Design System for React, but I introduced simple HTML code to create a new component that avoids having to maintain the knowledge to always include text with the spinner. This, of course, will cut down on correcting the code when a feature developer forgets this rule or is a new developer on the project. The Salesforce Engineering team has not only provided excellent components to use out of the box, but the team also included the blueprint documentation which allows feature developers to expand and potentially even contribute to the repository. design-system-react All of these efforts fall in line with my personal mission statement. If you are interested in the source code for this article, simply navigate to the following repository on GitLab: https://gitlab.com/johnjvester/having-fun-with-the-lightning-design-system Have a really great day!

Having (More) Fun Creating Components with the Lightning Design System for React

What are Self Healing Systems & How Can You Develop One? When people get injured, their bodies self-heal. What if technology could do the same? Companies are racing to develop self-healing systems, which could improve quality, cut costs and boost customer trust. For example, IBM is experimenting with ‘self-managing’ products that configure, protect and heal themselves. What Is A Self Healing System? A self-healing system can discover errors in its functioning and make changes to itself without human intervention, thereby restoring itself to a better-functioning state. There are three levels of self-healing systems, each of which has its own size and resource requirements: Application Level In typical applications, problems are documented in an ‘exceptions log’ for further examination. Most problems are minor and can be ignored. Serious problems may require the application to stop (for example, an inability to connect to a database that has been taken offline). By contrast, self-healing applications incorporate design elements that resolve problems. For example, applications that use arrange elements in a hierarchy and assign an actor’s problems to its supervisor. Many such libraries and frameworks facilitate applications that self-heal by design. Akka System Level Unlike application level self-healing, system level self-healing does not depend on a programming language or specific components. Rather, it can be generalized and applied to all services and applications, independent of their internal components. The most common system level errors include process failures (often resolved by redeploying or restarting) and response time issues (often resolved by scaling and descaling). Self-healing systems conduct health checks on different components and automatically attempt fixes (such as redeploying) to recuperate to their desired states. Hardware Level Hardware level self-healing redeploys services from an unhealthy node to a healthy one. It also conducts health checks on different components. Since true hardware level self-healing (for example, a machine that can heal failed memory or repair a broken hard disk) does not exist, current hardware level solutions are essentially system level solutions. Reactive Versus Preventive Healing Reactive Healing Reactive healing is healing in response to an error and is already in widespread use. For example, redeploying an application to a new physical node in response to an error, thereby preventing downtime, is reactive healing. The desirable level of reactive healing depends on how much risk a system can tolerate. For example, if a system relies on a single data center, the possibility of the entire data center losing power, resulting in all nodes not working, may be so slim that designing a system that responds to this possibility is unnecessary and expensive. However, if it is a critical system, it may make sense to design it to recuperate automatically after such an event. Preventive Healing Preventive healing proactively prevents errors. Take the example of proactively preventing processing time errors by using real-time data. You send an HTTP request to check the health of a service and better use resources. If it takes more than 500 milliseconds to respond, you design the system to scale it, and if it responds in less than 100 milliseconds, you design the system to descale it. However, using real-time data can be troublesome if response times change a lot, because the system will scale and descale constantly (this can use a lot of resources in rigid architecture, and a smaller amount of resources in a micro-services architecture). Combining real-time and historical data is a better (and also more complex) preventive healing approach. Using our response time example, you design a system that stores response time, memory and CPU information and uses an appropriate algorithm to process it alongside real-time data to predict future needs. So, if memory usage has been increasing steadily for the past hour and reaches a critical point of 90 percent, your system determines that scaling is appropriate, thereby preventing errors. Designing Self-Healing Systems: Three Principles & a Five-Point Roadmap Principles Naturally, if you have a deep understanding of your system, you will better be able to guess where a problem might occur and how you might respond. What scenarios are the most common? How serious are the errors that might occur? Know your system: Automation and distributed storage, computing and analytics make preventive approaches easy and affordable. A proactive, preventive approach can resolve errors before they occur. Design for prevention: Self-healing systems reduce the maintenance burden on your team. Even when errors or potential errors require human intervention, design the process so that resolution is easy and intuitive for the humans involved. Your team will thank you! Make it easy for the humans in the loop: Roadmap Use immutable infrastructure as code Automate testing to keep the codebase efficient Deploy holistic monitoring systems Employ leading-edge smart alerts, triggers and prescriptive analytics Think deeply about how the system can improve self-learning Conclusion Designing systems and applications that are self-healing (or even better, automatically determine when errors might occur and prevent them) can improve quality, cut costs and improve customer trust. Even the best systems still require human intervention, but they can be designed so that the intervention is light-touch and easy for the human. Unlike self-healing software and services, self-healing hardware is still in the sci-fi realm and is leading to a newfound appreciation for biology, spurring fresh interest in biological computing. Shaan Ray Previously published at https://lansaar.com/self-healing-systems/

Self Healing System Concept, Explained

You can read the previous post in this series . In this post I will cover partitioning. here Partitioning or sharding is the technique of breaking down a large dataset and distributing it across many disks. Reads/writes, after partitioning can be parallelised across many nodes. is combined with replication to achieve scalability. Partitioning One easy way to achieve partitioning is to divvy up the entire dataset based on some fixed criteria. For example for an e-commerce website, you can put all transactions for mobile phones on node 1, shoes on node 2 and so on. The problem with this approach is that this can result in skewed distribution. If mobile phones are the most popular items, the node handling mobile phone transactions will always be overloaded. One easy workaround is to assign partitions randomly. This ensures all your data gets spread evenly across nodes, but you must have already guessed the problem with this approach. When you issue a read query, it needs to be be sent to all the nodes, making reads costlier. Another way to handle this problem is to key based range partitions. You can first create a hash of key and then assign a range of resultant hash values to certain partitions. If you use a 32 bit hash function, your keys can be mapped to one of 2^32 – 1 hash values. You can then choose to assign keys 1–10 to say partition 1 and so on. The partition boundaries can be chosen randomly or manually. design While hash based partition ranges help in reducing asymmetric loads, there are no easy ways, at least at database level, to completely solve this problem. If for the said e-commerce website, iPhone X is the highest grossing product for one month, node partitions hosting iPhone X transactions will be stressed. The application developer in this case can add a 2 digit random key to original key hash and consequently distribute load for one key across 100 partitions. The challenge will again be reading as 100 parallel reads now need to be fired to find one transaction for iPhone X. Hence it makes sense to add random digits to only a few number of “hot” keys. That’s all I had to write in this post. I will post the next article in this series after a week or two. Till then I would love to hear your comments and feedback.

Fundamentals of System Design — Part 5

You can read the previous post in this series . here Applications need to have permanent storage for user or applications specific data. In memory data structures like linked list, arrays are optimised for access by CPU via pointers. Permanent storage is optimised for read/write access by clients/processes connecting to server. A very important aspect of permanent persistence is data modelling. I will devote this post on how to choose a good data model for your application. database Relational Database The most famous and prevalent data modelling technique is using relational tables. In relational tables, data is organised into records of a table. Tables are related to one another using primary key foreign key. There are a lot of reasons why your should choose relational table. You are just building out v1 of your app and data access patterns are not quite clear yet. Relational schemas are always a good first default choice. v1 of all apps are generally shit ( rightly told to me by a senior backend developer at my office :) ), and no one will fault you for starting with relational tables, instead of fancier NoSQL or Graph DB. You need to enforce strict schema on write constraints. You want to maintain zero data redundancy. Normalisation of schema in relational models has the effect of shredding information into many tables Your data model has many to one and many to many relationships. In other words you know which joins will be performed before hand. Joining and querying relational databases using a declarative language like SQL is one of the greatest secret sauce of relational databases. A lot of research and effort has gone into making relational queries super fast. An application developer just has to specify the expected data pattern of the query. The query engine will convert the SQL query into an optimised code to fetch/write data. NoSQL Database Application development is done using object oriented programming. However when data storage is done using tables, there is a translation required from objects to “shredded” relational tables. ORM frameworks provide boilerplate code to reduce the effort required for this translation, but still there is work to be done. NoSQL solves this problem by representing a record as a self contained JSON document. For example, let’s say we need to store patient demographic information along with his current conditions. One way to represent this record in a NoSQL database can be : { “first_name”: “John”, “last_name”: “Doe”, “conditions”:[ {“name” : “T2DM”, “onset”: “12–12–1990”}]} If you need read profile data for a patient in your app, you need not issue multiple joins as all data is inside one NoSQL document. Typically, if your data model exhibits a tree like, one to many relationships, using a NoSQL database might make more sense. In the patient example above, what if we wanted to store ICD10 standard codes for conditions instead of name of condition. This is a little troublesome in document based NoSQL databases as they have little support for joins. You can still do a join at the application layer but this will be always suboptimal compared to the joins done at a typical relational database layer. NoSQL databases become less desirable in this case. Lastly in case your data model does not have a fixed schema, going the NoSQL route might make more sense. Consider, the patient example above and say we need to also store patient’s date of birth. In NoSQL case, we can add a new field, ‘dob’ to new documents. At the application level we can also add code to handle reading old documents without dob field. In a relational database, the solution to handle dob would be to alter schema and make data migrations. Data migrations are slow and require downtime and consequently generally avoided. Graph Database Graph database makes a lot of sense when your application’s data model needs to support many ‘many-many’ relationships. The relational model can handle a few many to many relationships, but beyond a point all the relational joins become messy and slow. Using graph databases also provides an added advantage of easily extending relationships between heterogeneous objects. A graph consists of two kinds of objects — nodes and edges. Nodes contain description of objects or entities. Edges contain description of relationships between nodes. For example, say a person suffers from an allergic reaction because of exposure to an substance. You can model person, allergic reaction and substance as nodes. You can also model relationships between nodes in a graph database. For example a relationship between person and allergy can be a unidirectional relationship “person-has-allergy” from person node to allergy node. Relationship between allergy and and substance can be a unidirectional relationship “triggered-by-exposure-to” from allergy to substance. Why not do this in relational tables ? Well you can. You can create three tables — person, allergy and substance and set up the appropriate Pk-FK constraints. Like I said earlier, using graph databases makes sense when we have a lot of many-many relationships. For example, let’s say you introduce a location object in the overall scheme of things so that you can capture location of the person where the allergy reaction occurred. Location can be neighbourhood, city, state, country, continent or hemisphere. Basically, location information can be available at various levels of granularity. Using SQL to create a declarative query will be messy. needs to know in advance which joins will be part of the query. In graph database, on the other hand, you can traverse many nodes and edges before arriving at the target node. You can express the fact of traversing a graph once or many time quite concisely using a graph database declarative query language like Cypher, for Neo4j graph database. SQL Click on the link here to read . Fundamentals of System Design — Part 3

Fundamentals of System Design — Part 2

You can read the previous post in this series . here While designing systems, there are three primary concerns that should be addressed — reliability, scalability and maintainability. These terms are tossed around quite frequently and in this post I want to provide expositions for each of them. Reliability Reliability means the ability of a system to tolerate faults or problems in order to prevent failures or complete shutdowns. Large systems are built using fault intolerant components. The beauty and art of system is to build fault tolerant systems using fault intolerant components. design Faults can be categorised as hardware or software. For example, a large data centre, with hard disks with MTTF of 50–100 years, will witness disks going bust every day. Memory will be corrupted on a regular basis. Hardware faults can be addressed by adding redundancies. For example, disks can be stored in RAID configuration, data centres can have multiple power backups, CPUs can have support. hot-swapping Software faults can happen due to a variety of reasons. One runaway process can hog your system resources and cause a systematic crash across all nodes or the operating assumptions of the applications can change and result in crashes. Software faults can be handled by understanding business requirements and building resiliency to handle deviations from the same, better monitoring to publish warnings early on, better unit testing and finally by designing better abstractions and interfaces to easily isolate problems. Scalability Scalability is the system’s ability to deliver reasonable performance in face of increased load. System load can be described in terms of parameters that best translate an application’s raison d’être technically. For example for a social website, the expected number of the writes (posts) per second or reads (posts in timeline view) per second can be used to describe load. You can also consider peak reads/writes instead of average, for describing load on the system. networking Performance can be thought of as the system’s operating characteristic when system’s load parameter is changed. For example you might measure performance in terms of system average response time. You can also measure performance in terms of distribution of response times. So you might consider the 99th percentile of response time to be under 1 sec and average response time to be 300 ms. Performance metrics quite often are a part of your SLA with customers. There are many ways to achieve system scalability which I plan to cover in the subsequent posts in this series. Maintainability Maintainability means writing code that can easily be understood, refactored and upgraded by someone who is not the original author of the code. Any piece of spaghetti confusing code will ultimately be understood by machines. Good code should be readable and easily understood so that teams can collaborate. Good code should also have the right level of abstractions, clean APIs and interfaces so that new functionality can be easily built on top of existing codebase. Click on the link here to read Fundamentals of System Design — Part 2

Stories, News & Mentions about SYSTEM

Categories

Trending Topics

Stories, News & Mentions about SYSTEM

System’s Stories on HackerNoon

System's News & Mentions

Categories

Trending Topics