Open-source News

Budgie 10.7 sounds like a great desktop to use on Linux  GamingOnLinux

An optimization to Mesa's shader database cache eviction handling has been merged to Mesa 23.1 with a focus on benefiting Steam's shader pre-caching...

Red Hat Linux comes to Oracle Cloud  InfoWorld

Microsoft Defender can now isolate Linux devices in the name of ...  BetaNews

SAP endorses Red Hat Linux as strategic cloud platform  SiliconANGLE News

How To Run a Full Linux Desktop on a Chromebook  LinuxInsider.com

Red Hat-Oracle Collaboration Brings Red Hat Enterprise Linux to ...  ADT Magazine

A guide to fuzzy queries with Apache ShardingSphere xionggaoxiang Wed, 02/01/2023 - 03:00

Apache ShardingSphere is an open source distributed database and an ecosystem users and developers need for their databases to provide a customized and cloud-native experience. Its latest release contains many new features, including data encryption integrated with existing SQL workflows. Most importantly, it allows fuzzy queries of the encrypted data.

The problem

By parsing a user's SQL input and rewriting the SQL according to the user's encryption rules, the original data is encrypted and stored with ciphertext data in the underlying database simultaneously.

When a user queries the data, it fetches the ciphertext data from the database, decrypts it, and returns the decrypted original data to the user. However, because the encryption algorithm encrypts the whole string, users cannot run fuzzy queries.

Nevertheless, many businesses need fuzzy queries after the data is encrypted. In version 5.3.0, Apache ShardingSphere provides users with a default fuzzy query algorithm that supports encrypted fields. The algorithm also supports hot plugging, which users can customize. The fuzzy query can be achieved through configuration.

How to achieve fuzzy query in encrypted scenarios Load data to the in-memory database (IMDB)

First, load all the data into the IMDB to decrypt it. Then, it'll be like querying the original data. This method can achieve fuzzy queries. If the amount of data is small, this method will prove simple and cost-effective. However, if the quantity of data is large, it'll be a disaster.

Implement encryption and decryption functions consistent with database programs

The second method is to modify fuzzy query conditions and use the database decryption function to decrypt data first and then implement fuzzy query. This method's advantage is the low cost of implementation, development, and use.

Users only need to modify the previous fuzzy query conditions slightly. However, the ciphertext and encryption functions are stored together in the database, which cannot cope with the problem of account data leaks.

Native SQL:

select * from user where name like "%xxx%"

After implementing the decryption function:

ѕеlесt * frоm uѕеr whеrе dесоdе(namе) lіkе "%ххх%"Store after data masking

Implement data masking on ciphertext and then store it in a fuzzy query column. This method could lack precision.

For example, mobile number 13012345678 becomes 130****5678 after the masking algorithm is performed.

Perform encrypted storage after tokenization and combination

This method performs tokenization and combination on ciphertext data and then encrypts the resultset by grouping characters with fixed length and splitting a field into multiple ones. For example, we take four English characters and two Chinese characters as a query condition: ningyu1 uses the four-character as a group to encrypt, so the first group is ning, the second group ingy, the third group ngyu, the fourth group gyu1, and so on. All the characters are encrypted and stored in the fuzzy query column. If you want to retrieve all data that contains four characters, such as ingy, encrypt the characters and use a key like"%partial%" to query.

Shortcomings:

1. Increased storage costs: Free grouping will increase the amount of data, and the data length will increase after being encrypted.
2. Limited length in fuzzy query: Due to security issues, the length of free grouping cannot be too short or the rainbow table will easily crack it. Like the example I mentioned above, the length of fuzzy query characters must be greater than or equal to four letters/digits or two Chinese characters.

More great content Free online course: RHEL technical overview Learn advanced Linux commands Download cheat sheets Find an open source alternative Explore open source resources Single-character digest algorithm (default fuzzy query algorithm provided in ShardingSphere version 5.3.0)

Although the above methods are all viable, it's only natural to wonder if there's a better alternative. In our community, we find that single-character encryption and storage can balance performance and query but fails to meet security requirements.

So what's the ideal solution? Inspired by masking algorithms and cryptographic hash functions, we find that data loss and one-way functions can be used.

The cryptographic hash function should have the following four features:

1. It should be easy to calculate the hash value for any given message.
2. It should be difficult to infer the original message from a known hash value.
3. It should not be feasible to modify the message without changing the hash value.
4. There should only be a very low chance that two different messages produce the same hash value.

Security: Because of the one-way function, it's impossible to infer the original message. To improve the accuracy of the fuzzy query, we want to encrypt a single character, but the rainbow table will crack it.

So we take a one-way function (to ensure every character is the same after encryption) and increase the frequency of collisions (to ensure every string is 1: N backward), which greatly enhances security.

Fuzzy query algorithm

Apache ShardingSphere implements a universal fuzzy query algorithm using the below single-character digest algorithm org.apache.shardingsphere.encrypt.algorithm.like.CharDigestLikeEncryptAlgorithm.

public final class CharDigestLikeEncryptAlgorithm implements LikeEncryptAlgorithm { private static final String DELTA = "delta"; private static final String MASK = "mask"; private static final String START = "start"; private static final String DICT = "dict"; private static final int DEFAULT_DELTA = 1; private static final int DEFAULT_MASK = 0b1111_0111_1101; private static final int DEFAULT_START = 0x4e00; private static final int MAX_NUMERIC_LETTER_CHAR = 255; @Getter private Properties props; private int delta; private int mask; private int start; private Map charIndexes; @Override public void init(final Properties props) { this.props = props; delta = createDelta(props); mask = createMask(props); start = createStart(props); charIndexes = createCharIndexes(props); } private int createDelta(final Properties props) { if (props.containsKey(DELTA)) { String delta = props.getProperty(DELTA); try { return Integer.parseInt(delta); } catch (NumberFormatException ex) { throw new EncryptAlgorithmInitializationException("CHAR_DIGEST_LIKE", "delta can only be a decimal number"); } } return DEFAULT_DELTA; } private int createMask(final Properties props) { if (props.containsKey(MASK)) { String mask = props.getProperty(MASK); try { return Integer.parseInt(mask); } catch (NumberFormatException ex) { throw new EncryptAlgorithmInitializationException("CHAR_DIGEST_LIKE", "mask can only be a decimal number"); } } return DEFAULT_MASK; } private int createStart(final Properties props) { if (props.containsKey(START)) { String start = props.getProperty(START); try { return Integer.parseInt(start); } catch (NumberFormatException ex) { throw new EncryptAlgorithmInitializationException("CHAR_DIGEST_LIKE", "start can only be a decimal number"); } } return DEFAULT_START; } private Map createCharIndexes(final Properties props) { String dictContent = props.containsKey(DICT) && !Strings.isNullOrEmpty(props.getProperty(DICT)) ? props.getProperty(DICT) : initDefaultDict(); Map result = new HashMap<>(dictContent.length(), 1); for (int index = 0; index < dictContent.length(); index++) { result.put(dictContent.charAt(index), index); } return result; } @SneakyThrows private String initDefaultDict() { InputStream inputStream = CharDigestLikeEncryptAlgorithm.class.getClassLoader().getResourceAsStream("algorithm/like/common_chinese_character.dict"); LineProcessor lineProcessor = new LineProcessor() { private final StringBuilder builder = new StringBuilder(); @Override public boolean processLine(final String line) { if (line.startsWith("#") || 0 == line.length()) { return true; } else { builder.append(line); return false; } } @Override public String getResult() { return builder.toString(); } }; return CharStreams.readLines(new InputStreamReader(inputStream, Charsets.UTF_8), lineProcessor); } @Override public String encrypt(final Object plainValue, final EncryptContext encryptContext) { return null == plainValue ? null : digest(String.valueOf(plainValue)); } private String digest(final String plainValue) { StringBuilder result = new StringBuilder(plainValue.length()); for (char each : plainValue.toCharArray()) { char maskedChar = getMaskedChar(each); if ('%' == maskedChar) { result.append(each); } else { result.append(maskedChar); } } return result.toString(); } private char getMaskedChar(final char originalChar) { if ('%' == originalChar) { return originalChar; } if (originalChar <= MAX_NUMERIC_LETTER_CHAR) { return (char) ((originalChar + delta) & mask); } if (charIndexes.containsKey(originalChar)) { return (char) (((charIndexes.get(originalChar) + delta) & mask) + start); } return (char) (((originalChar + delta) & mask) + start); } @Override public String getType() { return "CHAR_DIGEST_LIKE"; } }

• Define the binary mask code to lose precision 0b1111_0111_1101 (mask).
• Save common Chinese characters with disrupted order like a map dictionary.
• Obtain a single string of Unicode for digits, English, and Latin.
• Obtain an index for a Chinese character belonging to a dictionary.
• Other characters fetch the Unicode of a single string.
• Add 1 (delta) to the digits obtained by different types above to prevent any original text from appearing in the database.
• Then convert the offset Unicode into binary, perform the AND operation with mask, and carry out a two-bit digit loss.
• Directly output digits, English, and Latin after the loss of precision.
• The remaining characters are converted to decimal and output with the common character start code after the loss of precision.

The fuzzy algorithm development progress The first edition

Simply use Unicode and mask code of common characters to perform the AND operation.

Mask: 0b11111111111001111101 The original character: 0b1000101110101111讯 After encryption: 0b1000101000101101設

Assuming we know the key and encryption algorithm, the original string after a backward pass is:

1.0b1000101100101101 謭 2.0b1000101100101111 謯 3.0b1000101110101101 训 4.0b1000101110101111 讯 5.0b1000101010101101 読 6.0b1000101010101111 誯 7.0b1000101000101111 訯 8.0b1000101000101101 設

Based on the missing bits, we find that each string can be derived 2^n Chinese characters backward. When the Unicode of common Chinese characters is decimal, their intervals are very large. Notice that the Chinese characters inferred backward are not common characters, and it's more likely to infer the original characters.

Image by:

(Xiong Gaoxiang, CC BY-SA 4.0)

The second edition

The interval of common Chinese characters in Unicode is irregular. We planned to leave the last few bits of Chinese characters in Unicode and convert them into decimal as an index to fetch some common Chinese characters. This way, when the algorithm is known, uncommon characters won't appear after a backward pass, and distractors are no longer easy to eliminate.

If we leave the last few bits of Chinese characters in Unicode, it has something to do with the relationship between the accuracy of fuzzy query and anti-decryption complexity. The higher the accuracy, the lower the decryption difficulty.

Let's take a look at the collision degree of common Chinese characters under our algorithm:

1. When mask=0b0011_1111_1111:

Image by:

(Xiong Gaoxiang, CC BY-SA 4.0)

2. When mask=0b0001_1111_1111:

Image by:

(Xiong Gaoxiang, CC BY-SA 4.0)

For the mantissa of Chinese characters, leave 10 and 9 digits. The 10-digit query is more accurate because its collision is much weaker. Nevertheless, if the algorithm and the key are known, the original text of the 1:1 character can be derived backward.

The nine-digit query is less accurate because nine-digit collisions are relatively stronger, but there are fewer 1:1 characters. Although we change the collisions regardless of whether we leave ten or nine digits, the distribution is unbalanced due to the irregular Unicode of Chinese characters. The overall collision probability cannot be controlled.

The third edition

In response to the unevenly distributed problem found in the second edition, we take common characters with disrupted order as the dictionary table.

1. The encrypted text first looks up the index in the out-of-order dictionary table. We use the index and subscript to replace the Unicode without rules. Use Unicode in case of uncommon characters. (Note: Evenly distribute the code to be calculated as far as possible.)

2. The next step is to perform the AND operation with a mask and lose two-bit precision to increase the frequency of collisions.

Let's take a look at the collision degree of common Chinese characters under our algorithm:

1. When mask=0b1111_1011_1101:

Image by:

(Xiong Gaoxiang, CC BY-SA 4.0)

2. When mask=0b0111_1011_1101:

Image by:

(Xiong Gaoxiang, CC BY-SA 4.0)

When the mask leaves 11 bits, you can see that the collision distribution is concentrated at 1:4. When the mask leaves ten bits, the number becomes 1:8. At this time, we only need to adjust the number of precision losses to control whether the collision is 1:2, 1:4 or 1:8.

If the mask is selected as 1, and the algorithm and key are known, there will be a 1:1 Chinese character because we calculate the collision degree of common characters at this time. If we add the missing four bits before the 16-bit binary of Chinese characters, the situation becomes 2^5=32 cases.

Since we encrypt the whole text, even if the individual character is inferred backward, there will be little impact on overall security and will not cause mass data leaks. At the same time, the premise of backward pass is to know the algorithm, key, delta, and dictionary, so it's impossible to achieve from the data in the database.

How to use fuzzy query

Fuzzy query requires the configuration of encryptors (encryption algorithm configuration), likeQueryColumn (fuzzy query column name), and likeQueryEncryptorName (encryption algorithm name of fuzzy query column ) in the encryption configuration.

Please refer to the following configuration. Add your own sharding algorithm and data source.

dataSources: ds_0: dataSourceClassName: com.zaxxer.hikari.HikariDataSource driverClassName: com.mysql.jdbc.Driver jdbcUrl: jdbc:mysql://127.0.0.1:3306/test?allowPublicKeyRetrieval=true username: root password: root rules: - !ENCRYPT encryptors: like_encryptor: type: CHAR_DIGEST_LIKE aes_encryptor: type: AES props: aes-key-value: 123456abc tables: user: columns: name: cipherColumn: name encryptorName: aes_encryptor assistedQueryColumn: name_ext assistedQueryEncryptorName: aes_encryptor likeQueryColumn: name_like likeQueryEncryptorName: like_encryptor phone: cipherColumn: phone encryptorName: aes_encryptor likeQueryColumn: phone_like likeQueryEncryptorName: like_encryptor queryWithCipherColumn: true props: sql-show: true

Insert

Logic SQL: insert into user ( id, name, phone, sex) values ( 1, '熊高祥', '13012345678', '男') Actual SQL: ds_0 ::: insert into user ( id, name, name_ext, name_like, phone, phone_like, sex) values (1, 'gyVPLyhIzDIZaWDwTl3n4g==', 'gyVPLyhIzDIZaWDwTl3n4g==', '佹堝偀', 'qEmE7xRzW0d7EotlOAt6ww==', '04101454589', '男')

Update

Logic SQL: update user set name = '熊高祥123', sex = '男1' where sex ='男' and phone like '130%' Actual SQL: ds_0 ::: update user set name = 'K22HjufsPPy4rrf4PD046A==', name_ext = 'K22HjufsPPy4rrf4PD046A==', name_like = '佹堝偀014', sex = '男1' where sex ='男' and phone_like like '041%'

Select

Logic SQL: select * from user where (id = 1 or phone = '13012345678') and name like '熊%' Actual SQL: ds_0 ::: select `user`.`id`, `user`.`name` AS `name`, `user`.`sex`, `user`.`phone` AS `phone`, `user`.`create_time` from user where (id = 1 or phone = 'qEmE7xRzW0d7EotlOAt6ww==') and name_like like '佹%'

Select: federated table sub-query

Logic SQL: select * from user LEFT JOIN user_ext on user.id=user_ext.id where user.id in (select id from user where sex = '男' and name like '熊%') Actual SQL: ds_0 ::: select `user`.`id`, `user`.`name` AS `name`, `user`.`sex`, `user`.`phone` AS `phone`, `user`.`create_time`, `user_ext`.`id`, `user_ext`.`address` from user LEFT JOIN user_ext on user.id=user_ext.id where user.id in (select id from user where sex = '男' and name_like like '佹%')

Delete

Logic SQL: delete from user where sex = '男' and name like '熊%' Actual SQL: ds_0 ::: delete from user where sex = '男' and name_like like '佹%'

The above example demonstrates how fuzzy query columns rewrite SQL in different SQL syntaxes to support fuzzy queries.

Wrap up

This article introduced you to the working principles of fuzzy query and used specific examples to demonstrate how to use it. I hope that through this article, you will have a basic understanding of fuzzy queries.

This article was originally published on Medium and has been republished with the author's permission.

Learn the working principles of fuzzy queries and follow along with specific examples of how to use them.

Databases What to read next This work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License. Register or Login to post a comment.

What's your community thinking pattern? Ron McFarland Wed, 02/01/2023 - 03:00

This article is the second and final part of a discussion of the research by Dave Logan, Bob King, and Halee Fischer-Wright.  If you haven't read the first part yet, you can do so here. These researchers defined five cultural thinking patterns in communities. In part one, I explained the first three of five thinking patterns. These communities are 20-150 people. I also suggested the responsibilities of an introducer-in-chief. This environmental thinking also refers to how the group behaves and how members talk to each other. To the researchers, each pattern has a identifying perspective:

• Community thinking pattern #1 (the most negative): "Life is miserable"
• Community thinking pattern #2: "My life is miserable"
• Community thinking pattern #3: "I'm great"
• Community thinking pattern #4: "We're great"
• Community thinking pattern #5 (the most optimistic): "Life's great"

In this article, I continue with their impressions of community thinking pattern #4 and conclude with thinking pattern #5 (the most optimistic).

Community thinking pattern #4: Environment

In this thinking and behaving community pattern, all five open organization principles of transparency, inclusivity, adaptability, collaboration, and community become extremely important to succeed, are actively applied, and are visible. In community thinking pattern #4, a community member transitions from personal gains to direct group or community gains as the focus. As the leader (introducer-in-chief), your role as a direct supervisor is less important than community member delegation. At this stage, you are not as powerful and productive as the total collective community.

According to the researchers, the roles of clients, suppliers, friends, mentors, and coaches are blurred at this stage. The people in your community form and focus on value-based relationships and identities. They cluster in larger, more transparent networking groups and develop community pride, as at this level, they focus on common community core values and interdependent strategies.

These communities are best formed by assembling like-minded, cooperative individuals who want to advance a specific communal goal. Community members are mostly already at a high individual achieving level, like those in community thinking pattern #3. The community ignores organizational boundaries when looking for community candidates.

In the researcher's words, "We're great," and indirectly, "Others are not" is the thought process. These "others" could be even different groups within the same organization.

Based on raw talent and high collaboration, this community can be powerful and hard to break. If the wrong (but talented) people are let into this culture, it could be hard to fix. Cooperation and transparency can weaken when the wrong choices are made. During the selection process, there are almost no organizational boundaries. It could explore "on loan" members from other departments, contract or part-time workers, contributors, volunteers or free agents, or anyone dedicated to the community purpose.

Regarding collaboration, a community at this stage feels comfortable interacting with other community members only. If invited for a cup of coffee, these community members consider asking at least two other people to come along to get collaboration casually started.

When the team hits difficulties, they seek out where solutions might be found. To do that, they seek diverse parties and ideas. They continually review and discuss:

1. What is going well.
2. What is not working well.
3. What the community can do to improve things.

Feelings within early community thinking pattern #4

Only community members who are individually successful in their specialty can move to community thinking pattern #4. If they have not excelled in their field, they come across as weak when they attempt to jump to thinking pattern #4.

Moving to community thinking pattern #4 requires group interaction and cooperation, not just individual talent. Therefore, open organization principles are needed, namely:

• Building communities to achieve more.
• Inclusivity of others (not just doing things alone or one-on-one giving directives and assignments).
• Adaptability to a new style of getting things done, collaboration, and transparency.

Image by:

Modified by Ron McFarland from the researcher’s material (Ronald McFarland, CC BY-SA 4.0)

To advance to a community thinking pattern #4 culture, you must begin with the culture's core values and noble cause (center). These are presumably compelling to everyone in the community, or else they wouldn't join in the first place. Next, move to the outcomes (completing a series of doable, measurable tasks at a predetermined time, leading to a specific goal). Finally, acquire the assets required to accomplish the tasks.

These questions come up:

1. What assets do we have right now, and what do we need to achieve the outcome? These could be equipment, technology, land, relationships and network, education, skills, goodwill, brand, public awareness, reputation, culture, or drive/passion.
2. Are there enough assets to achieve what we want?
3. Will the community's behavior accomplish the desired outcome?

The leader must consider the community's current culture and thinking to answer the above questions. Considerations include:

• Who is in the community?
• What do they care about?
• What are they working on?
• What does everyone want?
• To support members, who can I introduce them to?

A big difference between community thinking patterns #3 and #4 is that you, as the leader, must move away from the desire for personal success and redirect your attention to the community's success. This requires you to give up some control and rely on the community members to work with each other directly, make their own decisions, and accepting accountability for their actions. It starts with introducing two members to each other to address a common objective jointly.

Image by:

(Ronald McFarland, CC BY-SA 4.0)

They start working in gatherings of more than two people (beginning with three, including the leader). Sometimes you introduce two people to each other that might be suitable to work on an issue. You slowly exit the discussion and allow them to take over. Get out of the way and let your team members work directly with one another.

Feelings within middle community thinking pattern #4 Image by:

(Ronald McFarland, CC BY-SA 4.0)

After getting two people working on tasks together, you can start introducing more members with specific functions in mind by continually asking those same questions, starting with "Who is in the community?"

These introductions strengthen the community, increase collaboration, and widen inclusivity.

Feelings within late community thinking pattern #4 Image by:

(Ronald McFarland, CC BY-SA 4.0)

After members start working with each other on specific tasks that lead to desired outcomes, a high level of inclusivity and collaboration results. This increases community productivity to a globally superior level, leaving all competition behind in their market.

After identifying the community's thinking, behavior, and language, your action plan is to explore challenges that your team can't work on without involving outside help. Your goal is to find outside collaboration that encourages community thinking pattern #5 culture. This approach is needed when the community has been so competitive that they need a new, more global challenge.

Where once community thinking pattern #4 competed with other communities, now your community is willing to cooperate and collaborate for the overall greater good. This cooperation leads to a more enjoyable working environment. You must encourage and praise your community members every chance you can, and redirects personal praise directed at you to your community members.

Community thinking pattern #5 environment

People with this thinking pattern feel "life is great," according to the researchers. The members of this community have the same pride as thinking pattern #4, but without the competition. Conversely, they hope to collaborate with other communities to achieve a higher calling, like addressing climate change, cancer cures, avoiding war, overcoming disease, or hunger elimination. They seek other communities that have been extremely successful and have similar goals, objectives, and desires.

While in community thinking pattern #5, an organization is so successful that it has no need or desire to compete with other communities. Just competing bores them. A leader in community thinking pattern #5 is rewarded by community trust building, hard work, innovation, and collaboration. You are less interested in direct, personal rewards and praise, and more interested in boosting community, inclusivity, and collaboration.

Feelings within community thinking pattern #5

In this community thinking pattern, people are very successful. They're so successful that there is no more competition or desire to compete with others. Instead, they turn more toward vital, global, philanthropic goals. Most financial desires have weakened, because they have accumulated far more assets than they ever would hope to need. They have lost the desire to "win" against others and want to channel energy toward a higher goal.

Image by:

(Ronald McFarland, CC BY-SA 4.0)

What community are you in?

In your working environment, think about its greater purpose, and consider listening quality, problem-solving quality, ongoing job support, and participation level. Rank those factors from one to four and consider where development is needed. On average, a 3.5 would indicate a competitive thinking pattern #3 community and 4.5 an internally collaborative thinking pattern #4 community. To confirm the group thinking pattern level, also ask yourself what general feeling sticks out among most members:

• Life is miserable
• My life is miserable
• I'm great
• We're great
• Life's great

Armed with that information, consider what action is required.

Community thinking patterns in action

This is a fictional story of a man named Bob, a man who experienced all community thinking patterns from 1 to 5 (which few of us do).

Community thinking pattern #1 to #2

Imagine that in Bob's early life, he was abandoned by his family. As an orphan, he grew up in an unsafe environment, and had no one to encourage him to achieve anything beyond basic survival.

You meet Bob by chance, and after getting to know him, you tell Bob that you might be able to help him out. You are the introducer-in-chief.

First, you introduce Bob to Carol, who works as a janitor in a software development company. Carol says she could get Bob a job at this software company, as long as Bob can meet the basic requirements of the position. These are relatively basic requirements: Show up on time, do the work, and so on.

While Bob is doing janitorial work in the software company, he asks some of the code writers and programmers about the work they do. David, one of the programmers, is excited by Bob's interest in software development. He asks Bob whether he'd be interested in learning to program. Bob says, "I've always liked to do troubleshooting work and puzzles, so why not?" So David introduces Bob to a wide range of online software development tutorials. David is a secondary introducer-in-chief for Bob.

Bob studies a spare computer there in the company during his spare time. Mentoring him along, David starts to see real talent in Bob, so he introduces Bob to his college professor, Evelyn. Evelyn also sees the talent and drive in Bob, so she counsels him on how to develop his skills further.

Community thinking pattern #2 to #3

Bob proves himself to be a skilled programmer. Over time, his programs become more and more popular. He starts coding for money as a contractor, and as time passes he needs a staff to handle orders coming in. As sales come in, ideas for new programs materialize as well. He has so many ideas that he's overworked. He also hires staff to do programming, but he controls their assignments and tasks very closely. Even though all he's doing is supervising them, he's mentally exhausted at the end of the day.

Community thinking pattern #3 to #4

Bob goes back to Evelyn and asks what to do. Evelyn introduces him to Francis, an open organization consultant for small teams. Francis instructs Bob to get developers to talk to each other more directly, and let them come up with their own solutions and projects. Francis tells Bob that he has to let go of day-to-day supervising operations and start thinking about the overall operation of the team.

Over time, just like explained in the book Team of Teams, a well-oiled highly-efficient operation is created.

Community thinking pattern #4 to #5

After decades of massive successes, Bob has achieved more than his wildest dreams. His desire to be the best and beat all the competitor weakens. Bob wants to give back in a way that is most globally helpful. He starts approaching people with the same desires and meets Jeff, a global open organization project manager. Jeff specializes in global, multinational, long-term challenges like climate change, global green energy generation, energy waste reduction, food waste reduction, cybersecurity, international relations, world hunger, global migration and many others. Through Jeff's introductions, Bob starts a wide range of multinational projects. Again, just like in the book Team of Teams, Bob has gotten global teams collaborating to address really difficult, long-term challenges. Finally, Bob is at peace knowing how much he has achieved and will continue to achieve well into the future.

What community are you in?

In any working environment, you should think about its greater purpose. Consider listing quality, problem-solving quality, ongoing job support, and participation level. Rank those factors from 1 to 4, and consider where development is needed. On average, a 3.5 indicates a competitive thinking pattern #3 community. A 4.5 indicates an internally-collaborative thinking pattern #4 community.

To confirm the group thinking pattern level, also ask yourself what general feeling sticks out among most members: "Life is miserable", "My life is miserable", "I'm great", "We're great" or "Life's great". Armed with that, consider what action is required.

In the second part of this series, I explore community thinking patterns #4 and #5. Then, I provide a fictional scenario to illustrate thought processes and community influences.

Image by:

Melissa Hogan, CC BY-SA 4.0, via Wikimedia Commons

The Open Organization What to read next This work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License. Register or Login to post a comment.

How To Use Windows Subsystem for Linux (WSL)  ITPro Today

Ubuntu Pro is now available: here is what you need to know  Ghacks

The post Understanding The /etc/mtab File in Linux System first appeared on Tecmint: Linux Howtos, Tutorials & Guides .

In this article, we will explore the /etc/mtab file on a Linux system and understand the various parameters and directives included therein. What is /etc/mtab File in Linux The /etc/mtab file is a file

The post Understanding The /etc/mtab File in Linux System first appeared on Tecmint: Linux Howtos, Tutorials & Guides.

Winlink E850-96Board SBC is powered by Samsung Exynos 850 Octa-core Cortex-A55 SoC  CNX Software

During the course of this month on Phoronix were 224 original news articles pertaining to Linux / open-source / hardware and another 21 multi-page featured articles and Linux hardware reviews...

Linux 6.3 Features, Intel Sapphire Rapids & More Made For An ...  Phoronix

How to install the Neo4j graph database on Ubuntu Server 22.04  TechRepublic

Xfce 4.20 Desktop Environment Will Finally Bring Wayland Support  9to5Linux

Linux Mint 21.2 Reveals Codename, Teases Planned Features  OMG! Ubuntu!

Oracle cozies up to IBM, adds Red Hat Enterprise Linux  The Register

How to Install Metasploit on Ubuntu - Linux  MUO - MakeUseOf