Listado de la etiqueta: Group


The TODO Group, together with Linux Foundation Research, LF Training & Certification, api7.ai, Futurewei, Ovio, Salesforce, VMware, and X-Labs, is conducting a survey as part of a research project on the prevalence and outcomes of open source programs among different organizations across the globe. 

Open source program offices (OSPOs) help set open source strategies and improve an organization’s software development practices. Since 2018, the TODO Group has conducted surveys to assess the state of open source programs across the industry. Today, we are pleased to announce the launch of the 2022 edition featuring additional questions to add value to the community.

“The TODO Group was created to foster vendor-neutral best practices in open source usage and OSPO cultivation. Our annual OSPO survey is one of the best tools we have to understand how open source programs and initiatives are run at organizations worldwide, and to gain insight to inform existing and potential OSPO leaders of the nuances of fostering professional open source programs.”

Chris Aniszczyk, co-founder TODO Group and CTO, CNCF

“Thanks in part to the great community contributions received this year from open source folks engaged in OSPO-related topics, the OSPO 2022 Survey goes a step further to get insights and inform based on the most coetáneo OSPO needs across regions.”

Ana Jimenez Santamaria, OSPO Program Manager, TODO Group

The survey will generate insights into the following areas, including:

  • The extent of adoption of open source programs and initiatives 
  • Concerns around the hiring of open source developers 
  • Perceived benefits and challenges of open source programs
  • The impact of open source on organizational strategy

The survey will be available in English, Chinese, and Japanese. Please participate now; we intend to close the survey in mid-July. Privacy and confidentiality are important to us. Neither participant names, nor their company names, will be published in the final results.

To take the 2022 OSPO Survey, click the button below:



Source link


MongoDB database plays an important role in data storing and manipulating. To organize data, we create groups to gather the same sort of data in one place. Grouping can be on different attributes, whether from the count variable or any other feature. This tutorial will explain the group creation according to different fields of documents.

For the implementation of the phenomenon of groups according to multiple fields, we need to have some data in the database. We will create a database first. This is done by declaring the name of the database with the keyword “use.” For this implementation, we are using a database “demo.”

Merienda you are done with the database creation, data will be inserted into the database. And for the data entry we used to create “collections,” these are the containers that play an important role in storing limitless data in them. At a time, we can create many collections in a single database. Here we will create a database with the name “info.”

>> Db.createCollection(‘info’)

The response of MongoDB will be, “ok”; it is the confirmation of the creation of the collection. The data in the collection is entered row by row. So we will insert data into the collection. As this data will be used further in examples to create groups according to different fields, so we have entered many rows. Each time a different id is assigned to each row.

>>  db.info.insertOne ({«Name» : «Savid»,
«Age» : 28,
«Gender» : «Male»,
«Country»: «United States of America»})

Similarly, all the data will be inserted. You can see all inserted data by using the find() command

>> db.info.find().pretty()

Example 1: Group by Multiple Fields/Attributes

When we have a large set of data in the database, but we want to take a view of a few of them, then for this purpose, $groups are found. In this example, we will create a group to see some particular attributes from the collection. The group creador relies on the aggregate operation. An aggregate operation is used, to sum up the data according to the common fields. The Dollar “$” sign denotes the variable. Now apply a query on the above info collection.

A group depending on id, will be created. And then, only the age and gender documents are selected to be displayed. Whereas the entire data, including the name and country, are removed. This is somehow a filter that is used to limit the display of data.

>> db.info.aggregate([ {$group: {_id: {age:«$Age»,  gender:«$Gender»} } } ])

You can see that we have grouped each row according to id by limiting the data to two attributes.

Example 2: Group Through Multiple Fields by Applying a Condition

This refers to the grouping of the documents according to a specific condition. A group will be created on two attributes, and after the group creation, we will add a count variable to count the occurrence of the value of a specific document. And also, we have added a sorting order.

First, let us display the documents in our collection “new.” We have created a collection and added data to it earlier by following the same steps described above. We will only display all the items in the collection through the find() function.

The query will contain the group part first. The group is created on id; university and level are the two basic attributes that we want to get displayed. The variable we use gets the value from the collection and then assigns it to the query variable. All the values and conditions are not written directly in the command.

After the group creation, the condition is applied; it is to count and calculate the sum according to the levels of each document. After that, this answer will be arranged in descending order. This is done through the sort() functions. This function contains only two parameters; for the ascending value, it is 1, and for descending, it is -1.

>> db.new.aggregate([  {$group:{ _id:{ «university»:«$university», «level»:«$level»  },         «levelCount»:{«$sum»:1} }},  {«$sort»:{«levelCount»:1}} ])

The descending order will show that the greater amount of the level will be displayed first, and then the smaller one is displayed following the level document.

Example 3: MongoDb BUCKET Group by Multiple Fields

As the name indicates that the groups are found according to the bucket. This is done by creating the bucket aggregation. Bucket aggregation is the process of categorizing the documents into groups. This group acts like buckets. Each document is divided depending on the specific expression.

To elaborate on this concept, we will take a look at a collection we have created, and now we will apply the commands to that. A “draw” collection is created that stores the basic information regarding a person. We have displayed all the 4 rows entered into the collection earlier.

On the above data, we will apply a command to create a bucket (group) having the year as an attribute to group the data. We have also created boundaries in which the year of born and death are mentioned. The conditions applied on this command include the count variable to count the number of occurrences. We have also used a concatenation method here to combine both the first and the second names as strings. And also, the year of birth will be displayed. The id depends on the year.

When we compute this query, the resultant value will show that two rows are grouped depending on the age boundaries we have created.

Conclusion

The MongoDB feature of grouping depending on more than a single field is elaborated in this article by demonstrating the working of the aggregate operation in group creation. Any group function is incomplete without the aggregate feature. The group feature is applied directly through the different fields to limit the exposure of entire data. The grouping via multiple fields is also accomplished by applying a particular condition. In the end, we have described the creation of a bucket group that contains more items like a bucket.



Source link


As more and more organizations adopt open source initiatives and/or seek to mature their involvement in open source, they often face many challenges, such as educating developers on good open source practices, building policies and infrastructure, ensuring high-quality and frequent releases, engaging with developer communities, and contributing back to other projects effectively. They recognize that open source is a complex ecosystem that is a community of communities. It doesn’t follow traditional corporate rules, so guidance is needed to overcome cultural change. 

To help address these challenges and take advantage of the opportunities, organizations are turning to open source program offices (OSPOs). An OSPO is designed to be the center of competency for an organization’s open source operations and structure. This can include setting code use, distribution, selection, auditing, and other policies, as well as training developers, ensuring judicial compliance, and promoting and building community engagement that benefits the organization strategically. 

The Linux Foundation’s TODO Group’s mission is to help foster the adoption and improvement of OSPOs around the world. They are a tremendous resource, with extensive guides, a new mind map, an online course, case studies, and more. Check out their resources, community, and join their efforts

Thanks in part to their efforts, the OSPO movement is expanding across industries and regions of all types and sizes. However, due to the wide range of responsibilities and ways to operate, OSPO professionals often find it difficult to implement OSPO best practices, policies, processes, or tools for their open source management efforts.

To help people with these challenges, the TODO Group is introducing a new framework for in-person OSPO workshops. The framework is publicly available in ospology. This repo encapsulates a set of open initiatives (including an OSPO Mind Map 2.0, posible integral & regional meetings, an OSPO discussion forum, monthly OSPO News, and now, in-person workshops) to work in collaboration that aims to study and discuss the status of OSPOs and, ultimately, make them even more effective. 

TODO is piloting these in Europe first, and they are currently seeking collaborators to bring together the various communities involved in OSPO-specific topics and help organizations effectively implement OSPO Programs based on the specific needs for the region.

Backing up a bit, let’s look at the OSPOlogy.live framework. 

OSPOlogy.live framework in a nutshell

  • Follows an “unconference style,” meaning it’s a participants-driven meeting
  • Adheres to the Chatham House Rule in order to share openly and learn from each other 
  • Connects OSPOs with various open source communities involved in the open source activities that matter to them (e.g. policies, tooling, standards, and community building)
  • Takes place over two days and is an in-person event
  • Consists of prepared presentations, hands-on workshops, and space for networking
  • Falls under the Linux Foundation’s policies and code of conduct
  • Held at a location provided by one of the participants for free
  • Each participant pays for their own food, travel, and lodging. Meals may be free if workshop organizers find sponsors.
  • Participants can register their interest to receive an invite via Linux Foundation’s community platform as seats are limited.

With that overview, let’s dig in a little on how the workshop is conducted.

Unconference style

Typically at an unconference, the memorándum of the workshop portion is created by the attendees at the beginning of the meeting. Anyone who wants to initiate a discussion on a topic can claim a time and a space. OSPOlogy workshops are not fully an unconference as the first day is a series of prepared presentations, so you know what the sessions are before joining (1 or 2 will be chosen by the participants ahead of time). For Day 2, the workshops follow the unconference model. Participants vote on topics to be worked on that day. Participants may be asked to submit their topic before the workshop to accelerate/simplify the voting process.

Suggested workshop sections

  • OSPO USE CASES ➡️Expert-led panels or talks to share experiences and case studies from specific OSPOs
  • OSPO ACCELERATORS ➡️Presentation highlighting a specific activity within the specific project, such as outcomes of recent community activities. The aim of the presentation is to give people insights on various topics the communities are working on and get their feedback / to ask for contributions.
  • SHARED CHALLENGES ASSESSMENT ➡️ Description: Identify OSPO shared challenges / pain points on the OSPO Mind Map 2.0 and let the audience vote for the areas of interest (working groups) for the workshop breakout groups. For instance, focus areas can be specific activities within OSPO responsibilities.
  • BREAK OUT SESSIONS ➡️ Define goals and identify pain points. Each break out group aims to capture their challenges for the selected focus and if possible document their experiences/solutions.
  • NETWORKING

Interested in becoming a collaborator?

We can’t do this alone! If you are part of an open source community involved in OSPO-specific topics or an organization willing to help with the workshop planning, schedule and/or provide a space to kick off the first meet-up in Europe, we need your help! Please contact:

And check out the FAQs below. 

Don’t live in Europe? Pencil us in for when this is expanded. 

Not involved in an OSPO yet? Take time to check out the TODO Group and join the community to start your OSPOlogy journey.

Also, consider joining OSPONCon North America next week, June 21-24, 2022, either in Austin, Texas during the Open Source Summit or virtually. Register here.



Source link


SQLite gives the user a new set of clauses, one of which is a GROUP BY. In essence, the GROUP BY statement is an additional component of the select query that works in conjunction with other select commands to organize content differently. The GROUP BY statement is being used to create a set of rows based on the user’s query. It also provides single or multiple rows for every group. We may employ accrual accounting methods like SUM and COUNT as parameters in the GROUP BY command to provide more information about the given table. The FROM component of the SELECT query is followed by the GROUP BY statement. If a query includes a WHERE command, the GROUP BY command has to be placed after it.

If the SELECT query is an accumulated statement with a GROUP BY command, then each of the provided variables defined as an element of the GROUP BY command is evaluated for every column of the data. Each entry is then assigned to a “collection” based on the results. Entries with the same GROUP BY command results are assigned to a related group. Empty values are considered identical for aggregating rows. When evaluating a given argument in a GROUP BY command, the usual criteria for selecting a grouping configuration for analyzing textual values are applicable. The GROUP BY command’s provided argument will not have to be a parameter that appears in the output. In a GROUP BY command, the given argument cannot be an accumulated defined expression. We are going to explore how to utilize the GROUP BY command to develop a set of summarized rows from a series of values in this article.

Create Table:

First, we have to create a table named ‘Doctor’. There are different attributes of this table. The columns include Doc_id, Doc_fname, Doc_lname, Salary, and City. The attributes have different data types. The column ‘Doc_id’ has an integer data type, ‘Doc_fname’, ‘Doc_lname’, and ‘City’ has a TEXT data type. Whereas, the attribute ‘Salary’ contains the NUMERIC data type.

CREATE TABLE Doctor (
Doc_id INTEGER PRIMARY KEY,
Doc_fname TEXT,
Doc_lname TEXT,
Salary NUMERIC,
City TEXT
);

The output displays the effective execution of the above program.

Insert table:

In the next step, we have been using the INSERT query to insert the data of different doctors in the columns (Doc_id, Doc_fname, Doc_lname, Salary, and City) of the table ‘Doctor’.

INSERT INTO Doctor (Doc_id, Doc_fname, Doc_lname, Salary, City) VALUES (764, ‘Asma’, ‘Muneeb’, ‘40000’, ‘Islamabad’),
(381, ‘Laiba’, ‘Ajmal’, ‘90000’, ‘Swat’),
(904, ‘Muhammad’, ‘Ahmed’, ‘50000’, ‘Multan’),
(349, ‘Noor’, ‘Zain’, ‘120000’, ‘Karachi’),
(557, ‘Kashaan’, ‘Khalid’, ‘70000’, ‘Islamabad’);

We successfully run the query of INSERT as shown in the figure below.

SELECT query:

We can get the entire data of the table or acquire data from just a few columns. Whenever we want to obtain the information of some columns, we have to specify the names of that column in the SELECT query.

After executing the SELECT query, we get the entire data of the table ‘Doctor’. The table contains the ids, first names, last names, salaries, and cities of doctors.

Use GROUP BY clause:

In SQLite queries, the GROUP BY clause has been utilized in association with the SELECT command to organize similar data. In a SELECT query, the GROUP BY clause comes after the WHERE statement and just before the ORDER BY statement. In this instance, we have applied the GROUP BY clause on City.

>> SELECT * FROM Doctor GROUP BY City;

The data in the output is aggregated by the column of ‘City’.

Here, we just want to acquire the data of ids, first names, and salaries of doctors. The GROUP BY and ORDER BY clauses are employed on the column ‘Doc_id’.

>> SELECT Doc_id, Doc_fname, Salary FROM Doctor GROUP BY Doc_id ORDER BY Doc_id DESC;

In the resultant table, only data of the column ‘Doc_id’, ‘Doc_fname’, and salary will be obtained. The data in the table is sorted by using the ids of doctors in descending order.

Use GROUP BY command with SUM:

For the table ‘Doctor’, we are going to demonstrate using Group By statement along with the SUM function. Whether we want to consider the exact amount of income paid to every doctor, we will utilize the GROUP BY command as seen below. Here, the GROUP BY clause is employed on the column ‘Doc_fname’.

>> SELECT Doc_fname, SUM(salary) FROM Doctor GROUP BY Doc_fname;

The table of the outcome will be grouped by column ‘Doc_fname’.

Use GROUP BY command with COUNT:

We will modify the above query slightly by just adding the COUNT(Doc_lname) in the SELECT statement like the following screenshot to observe how to utilize the GROUP BY command with the COUNT method.

>> SELECT Doc_id, Doc_fname, Doc_lname, Salary, SUM(salary), COUNT(Doc_lname) FROM Doctor GROUP BY Doc_lname;

If we look at the result, it calculates the number of doctors in the table ‘Doctor’ that has the same last name. To determine the sum for every group, we will employ the SUM function.

Use the GROUP BY command for multiple columns:

We will also employ the GROUP BY statement for several columns. Let’s have a look at the instance in which we utilize the GROUP BY statement for two columns.

>> SELECT * FROM Doctor GROUP BY Salary, City;

The query returns the entire data of the table ‘Doctor’. The GROUP BY clause is applied to Salary and City both.

Conclusion:

With the help of several illustrations, we have explained when and how to utilize the Group by clause in the preceding article. The GROUP BY statement in SQLite is being applied to combine data in a single record wherein the result of one or even more defined columns is duplicated. This functionality will be used to reduce the extent of entries found by merely looking for distinct column values. We also noticed how the Group by statement could be used to do numerous operations dependent on our needs. We can utilize the GROUP BY command along with the COUNT and SUM functions. And we employ the GROUP BY command for multiple columns.



Source link