Stoic passions are various forms of emotional suffering in Stoicism. A passion is a disturbing and misleading force in the mind which occurs because of a failure to reason correctly. For Chrysippus, a famous Stoic philosopher, the passions are evaluative judgements. A person experiencing such an emotion has incorrectly valued an indifferent thing. A fault of judgement, some false notion of good or evil, lies at the root of each passion.

These states of feeling are disturbances of mental health which upset the natural balance of the soul. They are harmful because they conflict with right reason. The ideal Stoic would instead measure things at their real value, and see that the passions are not natural. To be free of the passions is to have a happiness which is self-contained. There would be nothing to fear - for unreason is the only evil; no cause for anger - for others cannot harm you.

The Stoics beginning with Zeno (the founder of the Stoic philosophy) arranged the passions under four headings:<ul><li>Distress - an irrational contraction, or a fresh opinion that something bad is present, at which people think it right to be depressed</li><li>Fear - an irrational aversion, or avoidance of an expected danger</li><li>Lust - an irrational desire, or pursuit of an expected good but in reality bad</li><li>Delight - an irrational swelling, or a fresh opinion that something good is present, at which people think it right to be elated</li></ul>

Two of these passions (distress and delight) refer to emotions currently present, and two of these (fear and lust) refer to emotions directed at the future. Thus there are just two states directed at the prospect of good and evil, but subdivided as to whether they are present or future.

Numerous subdivisions of the same class are brought under the head of the separate passions.<ul><li>Distress - envy, rivalry, jealousy, anxiety, depression</li><li>Fear - sluggishness, shame, fright</li><li>Lust - anger, rage, hatred</li><li>Delight - malice, rapture, ostentation</li></ul>

Subdivisions 

The wise person is someone who is free from passions. Instead, the sage experiences good-feelings which are clear-headed. These emotional impulses are the correct rational emotions. The Stoics listed the good-feelings under the headings of joy, wish, and caution. Thus if something is present which is a genuine good, then the wise person experiences an uplift in the soul - joy. The Stoics also subdivided the good-feelings.<ul><li>Joy - enjoyment, cheerfulness, good spirits</li><li>Wish - good intent, goodwill, welcoming, love</li><li>Caution - moral shame, reverence</li></ul>

philosophy

Philosophy

Stoic passions

JWT stands for JSON Web Token and represents an open standard (<a href="https://tools.ietf.org/html/rfc7519">RFC 7519</a>) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed. JWTs can be signed using a secret (with the HMAC algorithm) or a public/private key pair using RSA or ECDSA.

<ul><li>Authorization: The most common scenario for using JWT. Once the user is logged in, each subsequent request will include the JWT, allowing the user to access routes, services, and resources that are permitted with that token.</li><li>Information exchange: JSON Web Tokens are a good way of securely transmitting information between parties. Because JWTs can be signed—for example, using public/private key pairs—you can be sure the senders are who they say they are. Additionally, as the signature is calculated using the header and the payload, you can also verify that the content hasn't been tampered with.</li></ul>

Why should JWTs be used?

In its compact form, JSON Web Tokens consist of three parts separated by dots (.), which are:<ul><li>Header</li><li>Payload</li><li>Signature</li></ul>Therefore, a JWT typically looks like the following.aaaaa.bbbbb.ccccc I'll break down every part in the upcoming ideas.

JWTs structure

The header is the first part of a JWT token and it usually consists of two parts: the type of the token, and the signing algorithm being used. (see picture above - type is "JWT" and the signing algorithm is HMAC SHA256 ).This JSON is then Base64Url encoded.

JWT Headers

The payload is the second part of a JWT token and it contains the claims - statements about an entity (usually the user) and additional data. There are three types of claims: <ul><li>Registered - recommended predefined claims that provide a set of useful, interoperable claims. Some of them are: iss (issuer), exp (expiration time), sub (subject), aud (audience) etc. Names are short because a goal of JWTs is for the representation to be compact.</li><li>Public - can be defined at will by those using the JWT</li><li>Private - custom claims created to share information between parties</li></ul>This JSON is then Base64Url encoded.

JWT Payload

The signature is the third part of a JWT token. In order to create it we have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that (see picture).The signature is used to verify the message wasn't changed along the way, and, in the case of tokens signed with a private key, it can also verify that the sender of the JWT is who it says it is.

JWT Signature

Learn about JSON Web Tokens, what are they, how they work, when and why you should use them.

crypto

Cryptocurrency

technologyandthefuture

Technology & The Future

computerscience

Computer Science

What are JWTs?

If nothing else, death is a constant reminder of the fragility of life. It is a reminder of our existence and the time we have. Through death, we are reminded of why life is so valuable. But the hardest pill to swallow is that we, like everything else in life, must pass.

By knowing that death is imminent for all, we can learn to view death as a reminder of life. While death is scary and unknown, it is not yet here for us, and this means we still have today. By keeping this in mind, we have supreme power and control over our lives, our actions, and the direction we wish to go in. We have gratitude for our existence and the existence of those close to us. Every day that we wake is another opportunity to take action on our lives.

The time we have in this world is finite and it is our most valuable resource. With each passing day, we inch closer to death. But that does not mean our lives are meaningless. On the contrary, one could view this with excitement and understand that because life is not infinite, because there is an expiration date, it provides meaning to our existence and our actions. And this means that we can take action to do things that create purpose for our lives. It is through our actions and how we live our lives that we provide value not only to our time on this earth but also to the world.

Time

"Think not disdainfully of death, but look on it with favor; for even death is one of the things that Nature wills."

We must learn to accept the fact that we live and die. We do not know when it will come. We do not know how. But a guarantee is that it will one day come for us all. It’s scary and depressing at times. But by accepting our fate, we can embrace it and lean harder into the present moment. Instead of worrying about what’s on social media, we can embrace our ability to read, grow, and create the lives we want. We can cherish the times we have with friends and family. As it is, we are all on borrowed time.

Accepting the inevitable

Having a constant reminder that all things are temporary can help us live a more meaningful life.

If nothing else, death is a constant reminder of the fragility of life. It is a reminder of our existence and the time we have. Through death, we are reminded of why life is so valuable. But the…

personaldevelopment

Personal Development

Why death matters

Representational state transfer (REST) is a software architectural style that was created to guide the design and development of the architecture for the World Wide Web. REST defines a set of constraints for how the architecture of an Internet-scale distributed hypermedia system, such as the Web, should behave.

Representational state transfer

The REST architectural style is designed for client-server applications. The coupling between the client and the server must be as loose as possible to facilitate large-scale adoption. This is achieved by creating a layer of abstraction on the server by defining resources that encapsulate entities (e.g. files) on the server and so hiding the underlying implementation details (file server, database, etc.).

Clients can only access resources using URIs. In other words, the client requests a resource using a URI and the server responds with a representation of the resource. A representation of a resource is another important concept in REST - to ensure responses can be interpreted by the widest possible number of client applications a representation of the resource is sent in hypertext format.

The REST architectural style defines constraints, which, when applied to the system architecture, it gains desirable non-functional properties, such as performance, scalability, simplicity, modifiability, visibility, portability, and reliability.

The client-server design pattern enforces the separation of concerns, which helps the client and the server components evolve independently.By separating the user interface concerns (client) from the data storage concerns (server), we improve the portability of the user interface across multiple platforms and improve scalability by simplifying the server components.

Client–server architecture

Statelessness means that no session information is retained by the server. Relevant session data is sent to the sever by the client in such a way that every packet of information transferred can be understood in isolation.For example, in a RESTful API, making subsequent requests should be processed and fulfilled by the server without it keeping track of those requests, treating them independently.

Statelessness

The cacheable constraint requires that a response should implicitly or explicitly label itself as cacheable or non-cacheable.If the response is cacheable, the client application gets the right to reuse the response data later for equivalent requests and a specified period.

Cacheability

The layered system style allows an architecture to be composed of hierarchical layers by constraining component behavior.For example, in a layered system, each component cannot see beyond the immediate layer they are interacting with.

Layered system

By applying the principle of generality to the components interface, we can simplify the overall system architecture and improve the visibility of interactions.Multiple architectural constraints help in obtaining a uniform interface and guiding the behaviour of components.The following four constraints can achieve a uniform REST interface:<ul><li>Identification of resources</li><li>Manipulation of resources through representations</li><li>Self-descriptive messages</li><li>Hypermedia as the engine of application state</li></ul>

Uniform Interface

artificialintelligence

Artificial Intelligence

What is REST?

NGINX is open source software for web serving, reverse proxying, caching, load balancing, media streaming, and more. It started out as a web server designed for maximum performance and stability. In addition to its HTTP server capabilities, NGINX can also function as a proxy server for email (IMAP, POP3, and SMTP) and a reverse proxy and load balancer for HTTP, TCP, and UDP servers.

There are many features Nginx provides. Here are some examples:<ul><li>can be deployed to serve dynamic HTTP content on the network</li><li>can serve as a load balancer</li><li>handling of static files, index files and auto-indexing</li><li>reverse proxy with caching</li><li>FastCGI, SCGI, uWSGI support with caching</li></ul>

Features

Nginx is a reverse proxy for Gunicorn. Gunicorn can serve an app that supports WSGI (like Flask or Django) and Nginx sits in front of it and decides where a request should go. For example, if the incoming request is an http request, Nginx redirects it to gunicorn (hence the reverse proxy), if it is for a static file, it serves it itself.

Nginx with Gunicorn

Explore what NGINX is and learn how this high-performance software can act as a web server, load balancer, web accelerator, and more.

What is NGINX?

Gunicorn ‘Green Unicorn’ is a Python WSGI HTTP Server for UNIX. The Gunicorn server is broadly compatible with various web frameworks, simply implemented, light on server resources, and fairly speedy.

Gunicorn is based on the pre-fork worker model. This means that there is a central master process that manages a set of worker processes. The master never knows anything about individual clients. All requests and responses are handled completely by worker processes.

Design

The master process is a simple loop that listens for various process signals and reacts accordingly. It manages the list of running workers by listening for signals like TTIN, TTOU, and CHLD. TTIN and TTOU tell the master to increase or decrease the number of running workers. CHLD indicates that a child process has terminated, in this case the master process automatically restarts the failed worker.

Master

The most basic and the default worker type is a synchronous worker class that handles a single request at a time. This model is the simplest to reason about as any errors will affect at most a single request.&nbsp; sync worker does not support persistent connections - each connection is closed after response has been sent (even if you manually add Keep-Alive or Connection: keep-alive header in your application).

Sync workers

What is Gunicorn?

WSGI stands for Web Server Gateway Interface and represents a simple calling convention for web servers to forward requests to web applications or frameworks written in the Python programming language. The current version of WSGI, version 1.0.1, is specified in Python Enhancement Proposal (PEP) 3333.

The WSGI has two sides:<ul><li>the server/gateway side. This is often running full web server software such as Apache or Nginx.</li><li>the application/framework side. This is a Python callable, supplied by the Python program or framework.</li></ul>Between the server and the application, there may be one or more WSGI middleware components, which implement both sides of the API, typically in Python code. WSGI does not specify how the Python interpreter should be started, nor how the application object should be loaded or configured, and different frameworks and webservers achieve this in different ways.

Overview

A WSGI middleware component is a Python callable that is itself a WSGI application, but may handle requests by delegating to other WSGI applications. These applications can themselves be WSGI middleware components. A middleware component can perform such functions as:<ul><li>Routing a request to different application objects based on the target URL, after changing the environment variables accordingly.</li><li>Allowing multiple applications or frameworks to run side-by-side in the same process.</li><li>Load balancing and remote processing, by forwarding requests and responses over a network.</li></ul>

WSGI Middleware

A traditional web server does not understand or have any way to run Python applications.  Therefore the Python community came up with WSGI as a standard interface that modules and containers could implement. WSGI is now the accepted approach for running Python web applications. As shown in the above diagram, a WSGI server simply invokes a callable object on the WSGI application as defined by the PEP 3333 standard. Some examples of WSGI servers are: Green Unicorn, uWSGI, mod_wsgi and CherryPy.

Why is WSGI necessary?

Why use WSGI and not just point a web server directly at an application?<ul><li>WSGI gives you flexibility. Application developers can swap out web stack components for others. For example, a developer can switch from Green Unicorn to uWSGI without modifying the application or framework that implements WSGI.</li><li>WSGI servers promote scaling. Serving thousands of requests for dynamic content at once is the domain of WSGI servers. WSGI servers handle processing requests from the web server and deciding how to communicate those requests to an application framework's process.</li></ul>

WSGI's Purpose

What is WSGI?

Commenting involves placing Human Readable Descriptions inside of computer programs detailing what the Code is doing. Proper use of commenting can make code maintenance much easier, as well as helping make finding bugs faster. Further, commenting is very important when writing functions that other people will use. Remember, well documented code is as important as correctly working code.While it's easy to measure the quantity of comments in a program, it's hard to measure the quality, and the two are not necessarily correlated. A bad comment is worse than no comment at all.

All programs should be commented in such a manner as to easily describe (in English) the purpose of the code and any algorithms used to accomplish the purpose. A developer should be able to utilize a previously written program (or function) without ever having to look at the code, simply by reading the comments.Commenting is the "art" of describing what your program is going to do in "high level" English statements.

Commenting

"Programs must be written for people to read and only incidentally for machines to execute."

Your comments should be D.R.Y. The acronym stands for the programming maxim “Don’t Repeat Yourself.” This means that your code should have little to no redundancy. You don’t need to comment a piece of code that sufficiently explains itself. For example:<code>return a # Returns a</code>We can clearly see that 'a' is returned, so there’s no need to explicitly state this in a comment. It adds no information whatsoever and incurs a maintenance cost. This makes comments W.E.T., meaning you “wrote everything twice.”

Comments should not duplicate the code (D.R.Y)

A misuse of comments is to provide information that should have been in the code. An example is when someone names variables badly and then tries to add comments describing them: <code># A dictionary of families who live in each city</code><code>mydict = {</code><code> "Midtown": ["Powell", "Bran"],</code><code> "Norcross": ["Mont"]</code><code>}</code><code>def a(dict):</code><code> # For each city</code><code> for p in dict:</code><code> # If there are no families in the city</code><code> if not mydict[p]:</code><code> # Print it</code><code> print("None.")</code> <code>This script could have been made simpler by using obvious names for variables, functions and collections.</code>

Good comments do not excuse unclear code

The most infamous comment in the Unix source code is “You are not expected to understand this,” which appeared before some hairy context-switching code. It turned out that Dennis Ritchie and co-author Ken Thompson didn’t understand it themselves and later had to rewrite it. Warning readers away from your code is like turning on your car’s hazard lights: an admission that you’re doing something you know is illegal. Instead, rewrite the code to something you understand well enough to explain or, better yet, that is straightforward.

If you can’t write a clear comment, there may be a problem with the code

It’s a good idea to comment code that someone else might consider unneeded or redundant, such as this code: <code>final Object value = (new JSONTokener(jsonString)).nextValue(); </code><code>// Note that JSONTokener.nextValue() may return </code><code>// a value equals() to null. </code><code>if (value == null || value.equals(null)) { </code><code> return null; </code><code>}</code> Without the comment, someone might “simplify” the code or view it as a mysterious but essential incantation. Save future readers time and anxiety by writing down why the code is needed.

Explain unidiomatic code in comments

Most programmers use code that they find online. Including a reference to the source enables future readers to get the full context, such as:<ul><li>what problem was being solved</li><li>who provided the code</li><li>why the solution is recommended</li><li>what commenters thought of it</li><li>whether it still works</li></ul>For example, compare the follwowing pieces of code:<code>/** Converts a Drawable to Bitmap. via https://stackoverflow.com/a/46018816/2219998. */</code> <code>and</code> <code>// Magical formula taken from a stackoverflow post, reputedly related to </code><code>// human vision perception. </code><code>return (int) (0.3 * red + 0.59 * green + 0.11 * blue);</code>

Provide links to the original source of copied code

Comments should be added not just when initially writing code but also when modifying it, especially fixing bugs. Consider this comment: <code>// NOTE: At least in Firefox 2, if the user drags outside of the browser window,</code><code>// mouse-move (and even mouse-down) events will not be received until</code><code>// the user drags back inside the window. A workaround for this issue</code><code>// exists in the implementation for onMouseLeave().</code><code> @Override public void onMouseMove(Widget sender, int x, int y) { .. }</code> <code>This helps the reader understand the code and it is helpful for determining whether the code is still needed.</code>

Add comments when fixing bugs

Sometimes it’s necessary to check in code even though it has known limitations. While it can be tempting not to share known deficiencies in one’s code, it is better to make these explicit, such as with a TODO comment: <code>// TODO: We are making the decimal separator be a period,</code><code>// regardless of the locale of the phone. We need to think about</code><code>// how to allow comma as decimal separator, which will require</code><code>// updating number parsing and other places that transform numbers to strings</code> Using a standard format for such comments helps with measuring and addressing technical debt.

Use comments to mark incomplete implementations

Best practices for writing code comments

Stoicism is a school of Hellenistic philosophy founded by Zeno of Citium in Athens in the early 3rd century BC. It is a philosophy of personal ethics informed by its system of logic and its views on the natural world. According to its teachings, as social beings, the path to eudaimonia (happiness) is found in accepting the moment as it presents itself, by not allowing oneself to be controlled by the desire for pleasure or by the fear of pain, by using one's mind to understand the world and to do one's part in nature's plan, and by working together and treating others fairly and justly.

What is Stoicism?

The Stoics are especially known for teaching that "virtue is the only good" for human beings, and those external things - such as health, wealth, and pleasure - are not good or bad in themselves, but have value as "material for virtue to act upon". The Stoics also held that certain destructive emotions resulted from errors of judgment, and they believed people should aim to maintain a will that is "in accordance with nature". Because of this, the Stoics thought the best indication of an individual's philosophy was not what a person said but how a person behaved.

Virtue

<ul><li>Wisdom - the ability to define what is good, what is not good, and what is indifferent.</li><li>Courage - the opposing force of cowardice. Courage is not the elimination or fear, desire or anxiety, it is acting in the right way despite our fear, desire and anxieties.</li><li>Justice - our duty to our fellow man, and to our society. It’s the morality behind how we act, specifically in relation to our community and the people within it.</li><li>Temperance - relates to self restraint, self discipline and self control. It is our ability to choose long term well-being over short term satisfaction.</li></ul>

The four Stoic virtues

<h3>In his book, "A Guide to the Good Life", W. Irvine claims that the cause of sadness in people is a lack of moderation. We get bored of the item we wished and worked so hard for shortly after obtaining it. We rapidly start looking for the next "big" thing instead of being content with what we already have (hedonic adaptation). This was proven in a study where people's level of happiness was calculated (lottery winners vs people who suffered a tragic accident). Results showed that the happiness levels returned to normal (to the level before the incident) after a few months.</h3>

Exercises - pt 1.1

As mentioned in the previous idea, Stoics recommend wishing for what we already have. But how could we do this? They propose that we imagine losing something valuable (a job or an expensive item). This is the only way we could be content with what we have. By imagining this, not only will we be better prepared in the eventuality that the event actually happens and we lose that thing, but we'll also start appreciating what we have more, realizing that it could be taken from us at any moment. As Epictetus, a Stoic philosopher, once said, we should never forget that everything is temporary.

Exercises - pt 1.2

"Some things are in our control and others not." - Epictetus In today's world, it's easy to start comparing ourselves to others or care extensively about their opinions. The Stoics recommend focusing on yourself and on what you can do. Let's look at an example of the commonly-known dichotomy of control. Imagine you're playing a tennis match. Your goal should be to play as best as you can instead of winning the match. If your goal is to win but you lose, you'll be upset. Also, seeing that you're losing could make you play worse during the game.

Exercises - pt 2.1

Continuing on the previous idea, having this new mindset will not make you play better or worse, but will reduce the emotional baggage that can come with losing the match. This exercise is incredibly useful as it can be applied in a lot of different situations. It's raining and I have to bring an umbrella? Not my problem, I don't control that. My friend doesn't like my new shirt? That's not in my control. “Just keep in mind: the more we value things outside our control, the less control we have.”

Exercises - pt 2.2

The view from above exercise is designed to make us more aware of how small we really are and how little importance most things have. In other words, to give us a sense of the bigger picture.  It’s quite simple, you use your imagination to try and relate yourself to the whole world and beyond. This not only makes you realize how stupid some things that preoccupy your mind are, but it can also shed some light on the most important things in your life. A human life represents a tiny fraction of the whole span of the universe and this exercise can help us realise just that.

Exercises - pt 3

Contemplating the perfect person is another type of exercise that we as humans could use to achieve virtue and become better people. Writing down a list of qualities an ideal person has helps us have a clearer view of it, while keeping us on track with what's important for us.

Exercises - pt 4

A bedtime reflection / journaling is a good example of what we can do at the end of a day. Mentally replay your entire day and then ask yourself the following questions:<ul><li>Did I behave according to my principles?</li><li>Did I treat the people with whom I interacted with in a friendly and considerate manner?</li><li>What vices have I fought?</li></ul>A good tip here is to be brutally honest with yourself. It's just you and your mind, there's is no reason to hide anything or lie to yourself.

Exercises - pt 5

Although Stoicism was founded more than 2000 years ago, there is no doubt that its core principles and ideas can help people of all kinds that are in different stages of their lives, especially in this day and age where social media usage and depression/anxiety levels are seeing all time highs.

Conclusion

Why Stoicism matters

The ".save()" method is used to write a model instance to the database. It can be an existing record or even a new one. For an existing record, Django will run a SQL UPDATE statement on the database. For a new record, Django will run an INSERT.

Save

When updating an existing record, Django will update every field. That means, if you changed only one field on the model instance, all the fields will be updated (with the values staying the same). This is inefficient, especially if the model has many fields.Another problem is that if there's a significant amount of time in between the fetching of the record and the saving of it, it is possible that another request will have updated one of the fields on that record, and your model instance still has the old value.Calling ".save()" now will overwrite the new value that someone else saved.

Problems with save()

To prevent updating every field of the model you can use the update_fields parameter. It expects a list of fields that you want to save. The UPDATE that is run against the database then only updates those fields that you have specified.For example, in case we only want to update the price of a toy, we would run "toy.save(update_fields=["price"])".

Saving with update_fields

<ul><li>when creating a new record.</li><li>you have a model instance already, and you need to change some field values.</li><li>you've overridden the save() method to include some custom model logic.</li><li>you defined pre_save and post_save signals for that model.</li></ul>

When to use save

The ".update()" method is available on each queryset object of the ORM. For example, "Toy.objects.filter(price__lt=50).update(price=50)".This would update the price of all toys that are below a certain price. While this is for a range of records, it could also be used to update a single record: "Toy.objects.filter(name="hippo").update(price=120)".

Update

<ul><li>you are updating fields of one or many records (note: update cannot be used to create a new record, like save can).</li><li>you don't need to re-use a model instance after updating.</li><li>you don't need your overridden save() method or any pre_save or post_save signals to run.</li><li>you know what your new field values must be without having retrieved the record(s).</li></ul>

When to use update

To save data in Django, you normally use .save() on a model instance. However the ORM also provides a .update() method on queryset objects. So which one should you use? Let's take a look at each, and then decide which one to use in which situations. Save The .save() method is used to write a model instance to the database. It can be an existing record or even a new one. For an existing record, Django will run a SQL UPDATE statement on the database. For a new record, Django will run an INSERT. Before Django 3.0, it would …