Lifecycle Nature

C - Create

Create stands for creation phenomenon. This is the moment where an entity is given life to perform something. In design planning, you define the entry point of the entity here. We will go through a series of examples here.

Case I - Human

For human experiencing C phenomenon, it is the moment when ovum get fertilized successfully by a sperm. Now, it is up to the designers (the parent) to design the experience throughout the parenthood:

• Mother's Nurturing Needs
  • Pregnancy specific foods
  • Pregnancy check-up
  • Funding for Hospital fees after giving birth
  • Insurance for mother
  • Maternity leave applications
  • 9 Months plan of loving
  • ... etc.
• Child
  • Infancy foods, toys, furniture, etc.
  • Teen foods, toys, furniture, etc.
  • Education (pre-school, primary school, high school, pre-university, university)
  • Time management
  • etc.

and so on. From here, a designer (e.g. a father) can pre-predict the check-list of preparations before engaging to creating a child. This way, the experience in the future will be smoother. Notice that the checklist above goes through other considerations like a series of WH questions to dig out all the consideration factors.

Case II - Data Structure

In computer science, it is about when, what, where, who, and why to create a defined data structure. This is to ensure that a data entity is created in a controlled manners in order to prevent data mismanagement that contributes to security issues and resources hogging. Example, considering creating a data structure with:

• Why creating such data structure (e.g. what is the purpose of this data structure?)
• When to create such data structure (e.g. on initialization? when object needed? on-demand? failing? exception?)
• Who create such a data structure (e.g. global? another data structure? framework?)
• Where to create such data structure (e.g. from a library? from a framework? from own source codes?)
• What resources this data structure takes (e.g. cpu operation time, memory, etc.)

R - Read

Read stands for extracting information without alternation phenomenon. This is the moment where another entity (e.g. you) is getting some form of information from the object entity without altering it. We will go through some examples here.

Case I - Human

Say we see Marie is a girl we want to date with, she's our object entity. We go forward and make conversation with her. However, as you know, girl does not gives hint easily. She will hide certain information from you the way she wants until she's comfortable to reveal. To show sign of interests, we read information from her by her:

• Verbal communications like speaking tone, emotion, etc.
• Non-verbal communications like eye contacts, hands positions, sitting positions, hand gesture behaviors (e.g. playing with hairs), emotional expression, etc.
• Confirmation from her if she is really interested to speak with you.

As a designer, you normally go through a list of design experience like:

• Are the questions and topics making people uncomfortable?
• If she does not provide such information, what should I do next?
• If she does provide such information, what should I do next?
• etc.

Case II - Data Structure

When a data structure is created, the program/system is allowed to read data from it. Hence, the designer will have to think through the design for Read operations like:

• What are allowed/disallowed to read? (e.g. public/private access)
• When to read? (e.g. post-initialization/null as value)
• What to read? (e.g. data type)

U - Update

Update stands for adding or altering the internals of the entity. This is the moment where another entity (e.g. you) is modifying the internal information of the object entity either by adding or altering it. We will go through some examples here:

Case I - Human

From day to day, we are constantly learning new things from our infant stage to adulthood. We are constantly updating ourselves with new learning, new cells generations, new experiences etc. Also, say we keep practicing a skill again and again, we are constantly upgrading that particular skill set. Hence, we are constantly updating that skill set.

As a designer, you decide:

• What to update (e.g. Can you alter your name? What are the consequences? etc.)
• When to update (e.g. When to document up your knowledge? etc.)
• How to update (e.g. What are the preparations to update the data? How can we safely update the data?)

Case II - Data Structure

From data structure point of view, it is for a designer to decide when to update an object entity. These considerations include:

• What to update the data?
• When to update the data?
• How to update the data?
• How to verify a successful update?

The operations are usually write related. Example: addition or modifications.

D - Delete

Delete stands for removal, killing, or scrapping the entity. This is the moment where you officially destroy the object entity.

Case I - Human

This is when a human dies, destroying the physical traces of himself/herself and cease of his/her routine of functionality. Investigators normally backtracks the sign of human death to gather back some information of interests, like death causes, or legacy. A designer usually studies the death nature like:

• Why is the human dead? (e.g. age / murder / etc.)
• How is the human kills himself/herself?
• What is killed?
• How the death of the human affects others?
• etc.

Case II - Data Structure

This is when a data structure is deleted or scrapped. Upon scrapping, the data structure resources are returned to the operating system. As a designer, you usually study:

• Why is the data structure deleted? (e.g. crashes / no longer benefits / sensitive /etc.)
• How is the data structure deleted? (e.g. normal delete / zeroing-delete)
• What is killed? (e.g. what data will be deleted)
• Who still depends on such data?
• etc.

B - Backup

Backup stands for duplicating/cloning the object entity with respect to time. This involves time aspects where the cloned entity can either:

• acts on its own
• acts as a restoration point.

Case I - Human

Although we can precisely clone human at a same time due to quantum physics, our knowledge management in human resources management can. Say an employees' expertise on something is too vital to the company and this person is poising as a threat to the company, the manager can consider knowledge management by assigning existing employees to absorb the knowledge or documenting them. This way, when this employee left the company, other employees can take over without feeling the pain.

A designer usually design the experience based on risk mitigation, where:

• What are too risky to lose?
• When to perform backup?
• How is the backup performed?
• Where to store the backup?
• What are the risk mitigation strategy?

Case II - Data Structure

This is when we duplicate and clone data structure into another entity for storage or future restoration. Similarly, a designer can consider:

• What data are too vital to lose? (e.g. files, big data, etc.)
• When to perform backup? (e.g. nightly, periodic, ad-hoc, trigger-point)
• How is the backup performed? (e.g. geo-location, dual/single backup, online / offline, encrypted/decrypted)
• Where to store the backup? (e.g. locally in drawer, locally in office data-center / geo-located data-center)
• What are the risk mitigation strategy? (e.g. backup and restore on tigger point / periodic house-keeping)

Res - Restore

Restore stands for setting an object entity back to the value at a specific time of backup. Restoration involves time aspects where a backup cloned entity is available to setting the object entity value back to that given time point. In another word, we're performing time travel.

Case I - Human

Same case as backup: knowledge management. Once the risky employee left the company, there should be a restoration mitigation strategy be executed (e.g. having all the trained employees to fill in the gap). Given enough time, the operation should be restored successfully.

A designer usually design the experience based on:

• What are the available backup? (timestamp)
• When to perform restoration?
• What are the follow up after restoration process upto present time?

Case II - Data Structure

This is when we set the data back to the values at a given backup point of time. Similar to human case, a designer can consider:

• What are the available backup?
• What are the policy of to choose a backup?
• When to perform restoration?
• How to perform restoration?
• What are the follow up after restoration process upto present time?

That's all about life-cycle nature.