Categories
Cloud DevOps History Software Engineering

Agile Manifesto – The Manifesto for Agile Software Development

See also: Agile software development and DevOps

The Manifesto for Agile Software Development

Agile software development values

“Based on their combined experience of developing software and helping others do that, the seventeen signatories to the manifesto proclaimed that they value:[5]” (WP)

  • Individuals and interactions over processes and tools
  • Working software over comprehensive documentation
  • Customer collaboration over contract negotiation
  • Responding to change over following a plan

That is to say, the items on the left are valued more than the items on the right.

As Scott Ambler elucidated:[21]

  • Tools and processes are important, but it is more important to have competent people working together effectively.
  • Good documentation is useful in helping people to understand how the software is built and how to use it, but the main point of development is to create software, not documentation.
  • A contract is important but is no substitute for working closely with customers to discover what they need.
  • A project plan is important, but it must not be too rigid to accommodate changes in technology or the environment, stakeholders’ priorities, and people’s understanding of the problem and its solution.

Some of the authors formed the Agile Alliance, a non-profit organization that promotes software development according to the manifesto’s values and principles. Introducing the manifesto on behalf of the Agile Alliance, Jim Highsmith said,

The Agile movement is not anti-methodology, in fact many of us want to restore credibility to the word methodology. We want to restore a balance. We embrace modeling, but not in order to file some diagram in a dusty corporate repository. We embrace documentation, but not hundreds of pages of never-maintained and rarely-used tomes. We plan, but recognize the limits of planning in a turbulent environment. Those who would brand proponents of XP or SCRUM or any of the other Agile Methodologies as “hackers” are ignorant of both the methodologies and the original definition of the term hacker.— Jim Highsmith, History: The Agile Manifesto[22]

Agile software development principles

The Manifesto for Agile Software Development is based on twelve principles:[23]” (WP)

  1. Customer satisfaction by early and continuous delivery of valuable software.
  2. Welcome changing requirements, even in late development.
  3. Deliver working software frequently (weeks rather than months)
  4. Close, daily cooperation between business people and developers
  5. Projects are built around motivated individuals, who should be trusted
  6. Face-to-face conversation is the best form of communication (co-location)
  7. Working software is the primary measure of progress
  8. Sustainable development, able to maintain a constant pace
  9. Continuous attention to technical excellence and good design
  10. Simplicity—the art of maximizing the amount of work not done—is essential
  11. Best architectures, requirements, and designs emerge from self-organizing teams
  12. Regularly, the team reflects on how to become more effective, and adjusts accordingly

Categories

Sources:

Fair Use Sources:

Categories
DevOps Software Engineering

Software engineer

software engineer is a person who applies the principles of software engineering to the design, development, maintenance, testing, and evaluation of computer software.” (WP)

Occupation
Occupation typeProfession
Activity sectorsInformation technologySoftware industry
Description
CompetenciesRequirements analysis, specification development, algorithm design, software quality assurance, documentation tasks.
Education requiredVaries from bachelor’s degree to advanced degree in software engineering or related field

Education

Half of all practitioners today have degrees in computer scienceinformation systems, or information technology.[citation needed] A small, but growing, number of practitioners have software engineering degrees. In 1987, the Department of Computing at Imperial College London introduced the first three-year software engineering Bachelor’s degree in the UK and the world; in the following year, the University of Sheffield established a similar program.[1] In 1996, the Rochester Institute of Technology established the first software engineering bachelor’s degree program in the United States, however, it did not obtain ABET accreditation until 2003, the same time as Rice UniversityClarkson UniversityMilwaukee School of Engineering and Mississippi State University obtained theirs.[2] In 1997, PSG College of Technology in Coimbatore, India was the first to start a five-year integrated Master of Science degree in Software Engineering.[citation needed]

Since then, software engineering undergraduate degrees have been established at many universities. A standard international curriculum for undergraduate software engineering degrees, SE2004, was defined by a steering committee between 2001 and 2004 with funding from the Association for Computing Machinery and the IEEE Computer Society. As of 2004, in the U.S., about 50 universities offer software engineering degrees, which teach both computer science and engineering principles and practices. The first software engineering Master’s degree was established at Seattle University in 1979. Since then graduate software engineering degrees have been made available from many more universities. Likewise in Canada, the Canadian Engineering Accreditation Board (CEAB) of the Canadian Council of Professional Engineers has recognized several software engineering programs.

In 1998, the US Naval Postgraduate School (NPS) established the first doctorate program in Software Engineering in the world.[citation needed] Additionally, many online advanced degrees in Software Engineering have appeared such as the Master of Science in Software Engineering (MSE) degree offered through the Computer Science and Engineering Department at California State University, Fullerton. Steve McConnell opines that because most universities teach computer science rather than software engineering, there is a shortage of true software engineers.[3] ETS (École de technologie supérieure) University and UQAM (Université du Québec à Montréal) were mandated by IEEE to develop the Software Engineering Body of Knowledge (SWEBOK), which has become an ISO standard describing the body of knowledge covered by a software engineer.[4]

Other degrees

In business, some software engineering practitioners have CS or Software Engineering degrees. In embedded systems, some have electrical engineeringelectronics engineeringcomputer science with emphasis in “embedded systems” or computer engineering degrees, because embedded software often requires a detailed understanding of hardware. In medical software, practitioners may have medical informatics, general medical, or biology degrees.[citation needed]

Some practitioners have mathematicsscienceengineering, or technology (STEM) degrees. Some have philosophy (logic in particular) or other non-technical degrees.[citation needed] For instance, Barry Boehm earned degrees in mathematics. And, others have no degrees.[citation needed]

Profession

Employment

See also: Software engineering demographics

Most software engineers work as employees or contractors. Software engineers work with businesses, government agencies (civilian or military), and non-profit organizations. Some software engineers work on their own as consulting software engineers. Some organizations have specialists to perform all of the tasks in the software development process. Other organizations separate software engineers based on specific software-engineering tasks. These companies sometimes hire interns (possibly university or college students) over a short time. In large projects, software engineers are distinguished from people who specialize in only one role because they take part in the design as well as the programming of the project. In small projects, software engineers will usually fill several or all roles at the same time. Specializations include:

Impact of globalization

Most students in the developed world have avoided degrees related to software engineering because of the fear of offshore outsourcing (importing software products or services from other countries) and of being displaced by foreign visa workers.[5] Although government statistics do not currently show a threat to software engineering itself; a related career, computer programming does appear to have been affected.[6][7] Often one is expected to start out as a computer programmer before being promoted to software engineer. Thus, the career path to software engineering may be rough, especially during recessions.

Some career counselors suggest a student also focus on “people skills” and business skills rather than purely technical skills because such “soft skills” are allegedly more difficult to offshore. Reasonable command over reading, writing & speaking English is asked by most of employers.[8] It is the quasi-management aspects of software engineering that appear to be what has kept it from being impacted by globalization.[9]

Prizes

There are several prizes in the field of software engineering:[10]

  • The Codie awards is a yearly award issued by the Software and Information Industry Association for excellence in software development within the software industry.
  • Jolt Awards are awards in the software industry.
  • Stevens Award is a software engineering award given in memory of Wayne Stevens.

Use of the title “Engineer”

Main articles: Software engineering professionalism and Regulation and licensure in engineering

Origin of the term

Margaret Hamilton promoted the term “software engineering” during her work on the Apollo program. The term “engineering” was used to acknowledge that the work should be taken just as seriously as other contributions toward the advancement of technology. Hamilton details her use of the term:

When I first came up with the term, no one had heard of it before, at least in our world. It was an ongoing joke for a long time. They liked to kid me about my radical ideas. It was a memorable day when one of the most respected hardware gurus explained to everyone in a meeting that he agreed with me that the process of building software should also be considered an engineering discipline, just like with hardware. Not because of his acceptance of the new “term” per se, but because we had earned his and the acceptance of the others in the room as being in an engineering field in its own right.[11]

Suitability of the term

In each of the last few decades, at least one radical new approach has entered the mainstream of software development (e.g. Structured ProgrammingObject Orientation), implying that the field is still changing too rapidly to be considered an engineering discipline. Proponents argue that the supposedly radical new approaches are evolutionary rather than revolutionary.[citation needed]

Individual commentators have disagreed sharply on how to define software engineering or its legitimacy as an engineering discipline. David Parnas has said that software engineering is, in fact, a form of engineering.[12][13] Steve McConnell has said that it is not, but that it should be.[14] Donald Knuth has said that programming is an art and a science.[15] Edsger W. Dijkstra claimed that the terms software engineering and software engineer have been misused[improper synthesis?] and should be considered harmful, particularly in the United States.[16]

Regulatory classification

Canada

In Canada the use of the job title Engineer is controlled in each province by self-regulating professional engineering organizations who are also tasked with enforcement of the governing legislation. The intent is that any individual holding themselves out as an engineer has been verified to have been educated to a certain accredited level and their professional practice is subject to a code of ethics and peer scrutiny. It is also illegal to use the title Engineer in Canada unless an individual is licensed.

In Ontario, the Professional Engineers Act[17] stipulates a minimum education level of a three-year diploma in technology from a College of Applied Arts and Technology or a degree in a relevant science area.[18] However, engineering undergraduates and all other applicants are not allowed to use the title of engineer until they complete the minimum amount of work experience of four years in addition to completing the Professional Practice Examination (PPE). If the applicant does not hold an undergraduate engineering degree then they may have to take the Confirmatory Practice Exam or Specific Examination Program unless the exam requirements are waived by a committee.[19][20]

IT professionals with degrees in other fields (such as computer science or information systems) are restricted from using the title Software Engineer, or wording Software Engineer in a title, depending on their province or territory of residence.[citation needed]

In some instances, cases have been taken to court regarding the illegal use of the protected title Engineer.[21]

Europe

Throughout the whole of Europe, suitably qualified engineers may obtain the professional European Engineer qualification.

France

In France, the term ingénieur (engineer) is not a protected title and can be used by anyone, even by those who do not possess an academic degree.

However, the title Ingénieur Diplomé (Graduate Engineer) is an official academic title that is protected by the government and is associated with the Diplôme d’Ingénieur, which is one of the most prestigious academic degrees in France.

Iceland

The use of the title tölvunarfræðingur (computer scientist) is protected by law in Iceland.[22] Software engineering is taught in Computer Science departments in Icelandic universities. Icelandic law state that a permission must be obtained from the Minister of Industry when the degree was awarded abroad, prior to use of the title. The title is awarded to those who have obtained a BSc degree in Computer Science from a recognized higher educational institution.[23]

New Zealand

In New Zealand, the Institution of Professional Engineers New Zealand (IPENZ), which licenses and regulates the country’s chartered engineers (CPEng), recognizes software engineering as a legitimate branch of professional engineering and accepts application of software engineers to obtain chartered status provided they have a tertiary degree of approved subjects. Software Engineering is included whereas Computer Science is normally not.[24]

United States

The Bureau of Labor Statistics (BLS) classifies computer software engineers as a subcategory of “computer specialists”, along with occupations such as computer scientist, Programmer, Database administrator and Network administrator.[25] The BLS classifies all other engineering disciplines, including computer hardware engineers, as engineers.[26]

Many states prohibit unlicensed persons from calling themselves an Engineer, or from indicating branches or specialties not covered licensing acts.[27][28][29][30][31][32][33][34][35][36] In many states, the title Engineer is reserved for individuals with a Professional Engineering license indicating that they have shown minimum level of competency through accredited engineering education, qualified engineering experience, and engineering board’s examinations.[37][38][29][30][31][32][33][34][35][36]

In April 2013 the National Council of Examiners for Engineering and Surveying (NCEES) began offering a Professional Engineer (PE) exam for Software Engineering. The exam was developed in association with the IEEE Computer Society.[39] NCEES ended the exam in April 2019 due to lack of participation.[40]

See also

Wikimedia Commons has media related to Software engineers.

References

  1. ^ Cowling, A. J. 1999. The first decade of an undergraduate degree program in software engineering. Ann. Softw. Eng. 6, 1–4 (Apr. 1999), 61–90.
  2. ^ “ABET Accredited Engineering Programs”. April 3, 2007. Retrieved April 3,2007.
  3. ^ McConnell, Steve (July 10, 2003). Professional Software Development: Shorter Schedules, Higher Quality Products, More Successful Projects, Enhanced CareersISBN 978-0-321-19367-4.
  4. ^ Software Engineering — Guide to the software engineering body of knowledge (SWEBOK), International Organization for Standardization, 2015, retrieved January 11, 2020
  5. ^ “IT news, careers, business technology, reviews”Computerworld.
  6. ^ “Computer Programmers”.
  7. ^ “Software developer growth slows in North America | InfoWorld | News | 2007-03-13 | By Robert Mullins, IDG News Service”. Archived from the original on April 4, 2009.
  8. ^ “Hot Skills, Cold Skills”. Archived from the original on February 22, 2014.
  9. ^ Dual Roles: The Changing Face of IT
  10. ^ Some external links:
  11. ^ Lawrence, Snyder (2017). Fluency with information technology : skills, concepts, & capabilities ([Seventh edition] ed.). NY, NY. ISBN 978-0134448725OCLC 960641978.
  12. ^ Parnas, David L. (1998). “Software Engineering Programmes are not Computer Science Programmes”Annals of Software Engineering6: 19–37. doi:10.1023/A:1018949113292S2CID 35786237., p. 19: “Rather than treat software engineering as a subfield of computer science, I treat it as an element of the set, {Civil Engineering, Mechanical Engineering, Chemical Engineering, Electrical Engineering,….}.”
  13. ^ Parnas, David L. (1998). “Software Engineering Programmes are not Computer Science Programmes”Annals of Software Engineering6: 19–37. doi:10.1023/A:1018949113292S2CID 35786237., p. 20: “This paper argues that the introduction of accredited professional programs in software engineering, programmes that are modelled on programmes in traditional engineering disciplines will help to increase both the quality and quantity of graduates who are well prepared, by their education, to develop trustworthy software products.”
  14. ^ McConnell, Steve (August 2003). Professional Software Development: Shorter Schedules, Better Projects, Superior Products, Enhanced Careers. Boston, MA: Addison-Wesley. ISBN 0-321-19367-9., p. 39: “In my opinion, the answer to that question is clear: Professional software development should be engineering. Is it? No. But should it be? Unquestionably, yes. “
  15. ^ Knuth, Donald (1974). “Computer Programming as an Art” (PDF). Communications of the ACM17 (12): 667–673. doi:10.1145/361604.361612S2CID 207685720.Transcript of the 1974 Turing Award lecture.
  16. ^ Dijkstra, Edsger W; transcribed by Mario Béland (November 23, 2004) [First published December 3, 1993]. “There is still a war going on (manuscript Austin, 3 December 1993)”E. W. Dijkstra Archive. The University of Texas at Austin, Department of Computer Sciences. Retrieved February 17, 2007. When the term was coined in 1968 by F.L. Bauer of the Technological University of Munich, I welcomed it. [. . .] I interpreted the introduction of the term “software engineering” as an apt reflection of the fact that the design of software systems was an activity par excellence for the mathematical engineer. [. . .]. As soon the term arrived in the USA, it was relieved of all its technical content. It had to be so for in its original meaning it was totally unacceptable [. . .] In the meantime, software engineering has become an almost empty term, as was nicely demonstrated by Data General who overnight promoted all its programmers to the exalted rank of “software engineer”!
  17. ^ “Professional Engineers Act”. July 24, 2014.
  18. ^ “Academic Requirements”www.peo.on.ca.
  19. ^ “Confirmatory Exam Program”www.peo.on.ca.
  20. ^ “mybtechdegree.ca”mybtechdegree.ca.
  21. ^ ‘Professional Engineers of Ontario’ – “Quebec Engineers win court battle against Microsoft”
  22. ^ “Lög um löggildingu nokkurra starfsheita sérfræðinga í tækni- og hönnunargreinum” (in Icelandic). Parliament of Iceland – Althing. March 11, 1996. Retrieved August 25, 2014.
  23. ^ “Lög um breytingu á lögum nr. 8/1996, um löggildingu nokkurra starfsheita sérfræðinga í tækni- og hönnunargreinum, með síðari breytingum”Alþingi. Retrieved October 3, 2016.
  24. ^ “Good Practice Guidelines for Software Engineering in New Zealand” (PDF). IPENZ.
  25. ^ U.S Department of Labor and Statistics The 2000 Standard Occupational Classification (SOC) System: 15-0000 Computer and Mathematical Occupations
  26. ^ U.S Department of Labor and Statistics The 2000 Standard Occupational Classification (SOC) System: 17-0000 Architecture and Engineering Occupations
  27. ^ Florida Board of Professional Engineering. “The 2019 Florida Statutes”.
  28. ^ PROFESSIONAL ENGINEERS AND LAND SURVEYORS. “O.C.G.A. § 43-15-1” (PDF).
  29. a b NJ Engineering Board. “NEW JERSEY ADMINISTRATIVE CODE TITLE 13 LAW AND PUBLIC SAFETY CHAPTER 4 0” (PDF).
  30. a b SC Engineering Law. “Code of Laws – Title 40 – Chapter 22 – Engineers and Surveyors”.
  31. a b AL Engineering Law. “Alabama Law Regulating Practice of Engineering and Land Surveying” (PDF).
  32. a b VW Engineering Law. “West Virginia Engineering Law Statutes and Rules”(PDF).
  33. a b OK Engineering Law. “Oklahoma Statutes, Rules and Ethics for Professional Engineers” (PDF).
  34. a b NV Engineering Law. “NRS: Chapter 625 – Professional Engineers and Land Surveyors”Unlawful practice of engineering.
  35. a b MS Engineering Law. “Part 901: Rules and Regulations of the Mississippi Board of Licensure for Professional Engineers and Surveyors” (PDF).
  36. a b IL Engineering Law. “225 ILCS 325/ Professional Engineering Practice Act of 1989”.
  37. ^ Florida Board of Professional Engineering. “Chapter 471” (PDF).
  38. ^ GEORGIA BOARD OF PROFESSIONAL ENGINEERS AND LAND SURVEYORS. “O.C.G.A. § 43-15-1” (PDF).
  39. ^ “New Software Engineering Exam Approved for Licensure”. IEEE Computer Society. May 4, 2012. Retrieved August 6, 2018.
  40. ^ “NCEES discontinuing PE Software Engineering exam”. National Council of Examiners for Engineering and Surveying. March 13, 2018. Retrieved August 6,2018.

Categories

Sources:

Fair Use Sources:

Categories
Artificial Intelligence AWS Azure Bibliography C# .NET Cloud Data Science - Big Data DevOps DevSecOps-Security-Privacy GCP Go Programming Language Java JavaScript Kotlin Kubernetes Linux Networking Operating Systems PowerShell Python React Software Engineering Spring Framework Swift TypeScript Vue.js Framework

Manning Publications

See also Java Bibliography, JavaScript Bibliography, Python Bibliography

Manning publishes the best quality IT books in the industry.

Manning is an independent publisher, providing computer books for software developers, engineers, architects, system administrators, and managers. Our books also cover topics for young programmers, students, and occasionally children.

summary

Manning is an independent publisher of computer books and video courses for software developers, engineers, architects, system administrators, managers and all who are professionally involved with the computer business. We also publish for students and young programmers, including occasionally for children. We are an entirely virtual organization based on Shelter Island, New York, with many staff working from far-flung places like Manila and Zagreb.

company character

“Independent” means we are not owned by a large corporate entity and are free to make decisions without bureaucratic overhead. That has allowed us to innovate and be flexible and to quickly adjust what we do as we go. We were the first by several years to sell our books as unprotected PDFs, something that later became commonplace. We were the first to start selling books before they were finished, in the Manning Early Access Program. This gave our readers access to our content as soon as it was readable, and this too has become common in the industry. And it means we are thinking every day about new ways to satisfy our customers, some of which we hope you will be pleased to discover in the not-too-distant future.

how we improve

We published our first book in 1993 and have been learning from our successes, and even more from our mistakes, ever since. Every new book teaches us something that helps us improve:

  • How to choose the topics we publish on
  • How to find the right authors for each book
  • How to help authors write the best books they can
  • How to ensure the content is valuable and easy to learn
  • How to let readers know about our content

book series

We publish standalone titles as well as the following book series:

  • Hello!
  • In Action
  • In Practice
  • In Depth
  • In a Month of Lunches

availability

Readers can access our books through the Manning Early Access Program, O’Reilly Learning (formerly Safari Books Online), and iBooks. Print copies, wherever they are bought, come with free electronic versions in PDF, ePub and Kindle formats. With your print copy in hand, register it on the Manning site and you can download the digital versions from your account.

At this time, our eBooks are available only from Manning.com and Apple’s iBookstore.

https://www.manning.com/manning

Sources:

Fair Use Sources:

Categories
Bibliography Cloud Data Science - Big Data DevOps Software Engineering

Building Event-Driven Microservices: Leveraging Organizational Data at Scale

See also: Event-driven architecture (EDA), Microservices, API, API Bibliography – Application Programming Interface Books and References

Building Event-Driven Microservices: Leveraging Organizational Data at Scale, 1st Edition, by Adam Bellemare, 2020, B08C9V1FC9 (BEDM)

Fair Use Source: B08C9V1FC9 (BEDM)

About This Book:

Organizations today often struggle to balance business requirements with ever-increasing volumes of data. Additionally, the demand for leveraging large-scale, real-time data is growing rapidly among the most competitive digital industries. Conventional system architectures may not be up to the task. With this practical guide, you’ll learn how to leverage large-scale data usage across the business units in your organization using the principles of event-driven microservices.

Author Adam Bellemare takes you through the process of building an event-driven microservice-powered organization. You’ll reconsider how data is produced, accessed, and propagated across your organization. Learn powerful yet simple patterns for unlocking the value of this data. Incorporate event-driven design and architectural principles into your own systems. And completely rethink how your organization delivers value by unlocking near-real-time access to data at scale.

You’ll learn:

  • How to leverage event-driven architectures to deliver exceptional business value
  • The role of microservices in supporting event-driven designs
  • Architectural patterns to ensure success both within and between teams in your organization
  • Application patterns for developing powerful event-driven microservices
  • Components and tooling required to get your microservice ecosystem off the ground

About the Author:

Adam Bellemare is a Staff Engineer, Data Platform at Flipp. He’s held this position since 2017. He joined Flipp in 2014 as a senior developer at Flipp. Prior to that, he held positions in embedded software development and quality assurance. His expertise includes: Devops (Kafka, Spark, Mesos, Zookeeper Clusters. Programmatic Building, scaling, destroying); Technical Leadership (Bringing Avro formatting to our data end-to-end, championing Kafka as the event-driven microservice bus, prototyping JRuby, Scala and Java Kafka clients and focusing on removing technical impediments to allow for product delivery); Software Development (Building microservices in Java and Scala using Spark and Kafka libraries); and Data Engineering (Reshaping the way that behavioral data is collected from user devices and shared with our Machine Learning, Billing and Analytics teams).

Book Details:

  • ASIN : B08C9V1FC9
  • Publisher : O’Reilly Media; 1st edition (July 2, 2020)
  • Publication date : July 2, 2020
  • Print length : 511 pages

Table of Contents:

  1. Preface
    1. Conventions Used in This Book
    2. O’Reilly Online Learning
    3. How to Contact Us
    4. Acknowledgments
  2. 1. Why Event-Driven Microservices
    1. What Are Event-Driven Microservices?
    2. Introduction to Domain-Driven Design and Bounded Contexts
      1. Leveraging Domain Models and Bounded Contexts
      2. Aligning Bounded Contexts with Business Requirements
    3. Communication Structures
      1. Business Communication Structures
      2. Implementation Communication Structures
      3. Data Communication Structures
      4. Conway’s Law and Communication Structures
    4. Communication Structures in Traditional Computing
      1. Option 1: Make a New Service
      2. Option 2: Add It to the Existing Service
      3. Pros and Cons of Each Option
      4. The Team Scenario, Continued
      5. Conflicting Pressures
    5. Event-Driven Communication Structures
      1. Events Are the Basis of Communication
      2. Event Streams Provide the Single Source of Truth
      3. Consumers Perform Their Own Modeling and Querying
      4. Data Communication Is Improved Across the Organization
      5. Accessible Data Supports Business Communication Changes
    6. Asynchronous Event-Driven Microservices
      1. Example Team Using Event-Driven Microservices
    7. Synchronous Microservices
      1. Drawbacks of Synchronous Microservices
      2. Benefits of Synchronous Microservices
    8. Summary
  3. 2. Event-Driven Microservice Fundamentals
    1. Building Topologies
      1. Microservice Topology
      2. Business Topology
    2. The Contents of an Event
    3. The Structure of an Event
      1. Unkeyed Event
      2. Entity Event
      3. Keyed Event
    4. Materializing State from Entity Events
    5. Event Data Definitions and Schemas
    6. Microservice Single Writer Principle
    7. Powering Microservices with the Event Broker
      1. Event Storage and Serving
      2. Additional Factors to Consider
    8. Event Brokers Versus Message Brokers
      1. Consuming from the Immutable Log
      2. Providing a Single Source of Truth
    9. Managing Microservices at Scale
      1. Putting Microservices into Containers
      2. Putting Microservices into Virtual Machines
      3. Managing Containers and Virtual Machines
    10. Paying the Microservice Tax
    11. Summary
  4. 3. Communication and Data Contracts
    1. Event-Driven Data Contracts
      1. Using Explicit Schemas as Contracts
      2. Schema Definition Comments
      3. Full-Featured Schema Evolution
      4. Code Generator Support
      5. Breaking Schema Changes
    2. Selecting an Event Format
    3. Designing Events
      1. Tell the Truth, the Whole Truth, and Nothing but the Truth
      2. Use a Singular Event Definition per Stream
      3. Use the Narrowest Data Types
      4. Keep Events Single-Purpose
      5. Minimize the Size of Events
      6. Involve Prospective Consumers in the Event Design
      7. Avoid Events as Semaphores or Signals
    4. Summary
  5. 4. Integrating Event-Driven Architectures with Existing Systems
    1. What Is Data Liberation?
      1. Compromises for Data Liberation
      2. Converting Liberated Data to Events
    2. Data Liberation Patterns
    3. Data Liberation Frameworks
    4. Liberating Data by Query
      1. Bulk Loading
      2. Incremental Timestamp Loading
      3. Autoincrementing ID Loading
      4. Custom Querying
      5. Incremental Updating
      6. Benefits of Query-Based Updating
      7. Drawbacks of Query-Based Updating
    5. Liberating Data Using Change-Data Capture Logs
      1. Benefits of Using Data Store Logs
      2. Drawbacks of Using Data Base Logs
    6. Liberating Data Using Outbox Tables
      1. Performance Considerations
      2. Isolating Internal Data Models
      3. Ensuring Schema Compatibility
      4. Capturing Change-Data Using Triggers
    7. Making Data Definition Changes to Data Sets Under Capture
      1. Handling After-the-Fact Data Definition Changes for the Query and CDC Log Patterns
      2. Handling Data Definition Changes for Change-Data Table Capture Patterns
    8. Sinking Event Data to Data Stores
    9. The Impacts of Sinking and Sourcing on a Business
    10. Summary
  6. 5. Event-Driven Processing Basics
    1. Composing Stateless Topologies
      1. Transformations
      2. Branching and Merging Streams
    2. Repartitioning Event Streams
      1. Example: Repartitioning an Event Stream
    3. Copartitioning Event Streams
      1. Example: Copartitioning an Event Stream
    4. Assigning Partitions to a Consumer Instance
      1. Assigning Partitions with the Partition Assignor
      2. Assigning Copartitioned Partitions
      3. Partition Assignment Strategies
    5. Recovering from Stateless Processing Instance Failures
    6. Summary
  7. 6. Deterministic Stream Processing
    1. Determinism with Event-Driven Workflows
    2. Timestamps
      1. Synchronizing Distributed Timestamps
      2. Processing with Timestamped Events
    3. Event Scheduling and Deterministic Processing
      1. Custom Event Schedulers
      2. Processing Based on Event Time, Processing Time, and Ingestion Time
      3. Timestamp Extraction by the Consumer
      4. Request-Response Calls to External Systems
    4. Watermarks
      1. Watermarks in Parallel Processing
    5. Stream Time
      1. Stream Time in Parallel Processing
    6. Out-of-Order and Late-Arriving Events
      1. Late Events with Watermarks and Stream Time
      2. Causes and Impacts of Out-of-Order Events
      3. Time-Sensitive Functions and Windowing
    7. Handling Late Events
    8. Reprocessing Versus Processing in Near-Real Time
    9. Intermittent Failures and Late Events
    10. Producer/Event Broker Connectivity Issues
    11. Summary and Further Reading
  8. 7. Stateful Streaming
    1. State Stores and Materializing State from an Event Stream
    2. Recording State to a Changelog Event Stream
    3. Materializing State to an Internal State Store
      1. Materializing Global State
      2. Advantages of Using Internal State
      3. Disadvantages of Using Internal State
      4. Scaling and Recovery of Internal State
    4. Materializing State to an External State Store
      1. Advantages of External State
      2. Drawbacks of External State
      3. Scaling and Recovery with External State Stores
    5. Rebuilding Versus Migrating State Stores
      1. Rebuilding
      2. Migrating
    6. Transactions and Effectively Once Processing
      1. Example: Stock Accounting Service
      2. Effectively Once Processing with Client-Broker Transactions
      3. Effectively Once Processing Without Client-Broker Transactions
    7. Summary
  9. 8. Building Workflows with Microservices
    1. The Choreography Pattern
      1. A Simple Event-Driven Choreography Example
      2. Creating and Modifying a Choreographed Workflow
      3. Monitoring a Choreographed Workflow
    2. The Orchestration Pattern
      1. A Simple Event-Driven Orchestration Example
      2. A Simple Direct-Call Orchestration Example
      3. Comparing Direct-Call and Event-Driven Orchestration
      4. Creating and Modifying an Orchestration Workflow
      5. Monitoring the Orchestration Workflow
    3. Distributed Transactions
      1. Choreographed Transactions: The Saga Pattern
      2. Orchestrated Transactions
    4. Compensation Workflows
    5. Summary
  10. 9. Microservices Using Function-as-a-Service
    1. Designing Function-Based Solutions as Microservices
      1. Ensure Strict Membership to a Bounded Context
      2. Commit Offsets Only After Processing Has Completed
      3. Less Is More
    2. Choosing a FaaS Provider
    3. Building Microservices Out of Functions
    4. Cold Start and Warm Starts
    5. Starting Functions with Triggers
      1. Triggering Based on New Events: The Event-Stream Listener
      2. Triggering Based on Consumer Group Lag
      3. Triggering on a Schedule
      4. Triggering Using Webhooks
      5. Triggering on Resource Events
    6. Performing Business Work with Functions
    7. Maintaining State
    8. Functions Calling Other Functions
      1. Event-Driven Communication Pattern
      2. Direct-Call Pattern
    9. Termination and Shutdown
    10. Tuning Your Functions
      1. Allocating Sufficient Resources
      2. Batch Event-Processing Parameters
    11. Scaling Your FaaS Solutions
    12. Summary
  11. 10. Basic Producer and Consumer Microservices
    1. Where Do BPCs Work Well?
      1. Integration with Existing and Legacy Systems
      2. Stateful Business Logic That Isn’t Reliant Upon Event Order
      3. When the Data Layer Does Much of the Work
      4. Independent Scaling of the Processing and Data Layer
    2. Hybrid BPC Applications with External Stream Processing
      1. Example: Using an External Stream-Processing Framework to Join Event Streams
    3. Summary
  12. 11. Heavyweight Framework Microservices
    1. A Brief History of Heavyweight Frameworks
    2. The Inner Workings of Heavyweight Frameworks
    3. Benefits and Limitations
    4. Cluster Setup Options and Execution Modes
      1. Use a Hosted Service
      2. Build Your Own Full Cluster
      3. Create Clusters with CMS Integration
    5. Application Submission Modes
      1. Driver Mode
      2. Cluster Mode
    6. Handling State and Using Checkpoints
    7. Scaling Applications and Handling Event Stream Partitions
      1. Scaling an Application While It Is Running
      2. Scaling an Application by Restarting It
      3. Autoscaling Applications
    8. Recovering from Failures
    9. Multitenancy Considerations
    10. Languages and Syntax
    11. Choosing a Framework
    12. Example: Session Windowing of Clicks and Views
    13. Summary
  13. 12. Lightweight Framework Microservices
    1. Benefits and Limitations
    2. Lightweight Processing
    3. Handling State and Using Changelogs
    4. Scaling Applications and Recovering from Failures
      1. Event Shuffling
      2. State Assignment
      3. State Replication and Hot Replicas
    5. Choosing a Lightweight Framework
      1. Apache Kafka Streams
      2. Apache Samza: Embedded Mode
    6. Languages and Syntax
    7. Stream-Table-Table Join: Enrichment Pattern
    8. Summary
  14. 13. Integrating Event-Driven and Request-Response Microservices
    1. Handling External Events
      1. Autonomously Generated Events
      2. Reactively Generated Events
    2. Handling Autonomously Generated Analytical Events
    3. Integrating with Third-Party Request-Response APIs
    4. Processing and Serving Stateful Data
      1. Serving Real-Time Requests with Internal State Stores
      2. Serving Real-Time Requests with External State Stores
    5. Handling Requests Within an Event-Driven Workflow
      1. Processing Events for User Interfaces
    6. Micro-Frontends in Request-Response Applications
    7. The Benefits of Microfrontends
      1. Composition-Based Microservices
      2. Easy Alignment to Business Requirements
    8. Drawbacks of Microfrontends
      1. Potentially Inconsistent UI Elements and Styling
      2. Varying Microfrontend Performance
      3. Example: Experience Search and Review Application
    9. Summary
  15. 14. Supportive Tooling
    1. Microservice-to-Team Assignment System
    2. Event Stream Creation and Modification
    3. Event Stream Metadata Tagging
    4. Quotas
    5. Schema Registry
    6. Schema Creation and Modification Notifications
    7. Offset Management
    8. Permissions and Access Control Lists for Event Streams
    9. State Management and Application Reset
    10. Consumer Offset Lag Monitoring
    11. Streamlined Microservice Creation Process
    12. Container Management Controls
    13. Cluster Creation and Management
      1. Programmatic Bringup of Event Brokers
      2. Programmatic Bringup of Compute Resources
      3. Cross-Cluster Event Data Replication
      4. Programmatic Bringup of Tooling
    14. Dependency Tracking and Topology Visualization
      1. Topology Example
    15. Summary
  16. 15. Testing Event-Driven Microservices
    1. General Testing Principles
    2. Unit-Testing Topology Functions
      1. Stateless Functions
      2. Stateful Functions
    3. Testing the Topology
    4. Testing Schema Evolution and Compatibility
    5. Integration Testing of Event-Driven Microservices
    6. Local Integration Testing
      1. Create a Temporary Environment Within the Runtime of Your Test Code
      2. Create a Temporary Environment External to Your Test Code
      3. Integrate Hosted Services Using Mocking and Simulator Options
      4. Integrate Remote Services That Have No Local Options
    7. Full Remote Integration Testing
      1. Programmatically Create a Temporary Integration Testing Environment
      2. Testing Using a Shared Environment
      3. Testing Using the Production Environment
    8. Choosing Your Full-Remote Integration Testing Strategy
    9. Summary
  17. 16. Deploying Event-Driven Microservices
    1. Principles of Microservice Deployment
    2. Architectural Components of Microservice Deployment
      1. Continuous Integration, Delivery, and Deployment Systems
      2. Container Management Systems and Commodity Hardware
    3. The Basic Full-Stop Deployment Pattern
    4. The Rolling Update Pattern
    5. The Breaking Schema Change Pattern
      1. Eventual Migration via Two Event Streams
      2. Synchronized Migration to the New Event Stream
    6. The Blue-Green Deployment Pattern
    7. Summary
  18. 17. Conclusion
    1. Communication Layers
    2. Business Domains and Bounded Contexts
    3. Shareable Tools and Infrastructure
    4. Schematized Events
    5. Data Liberation and the Single Source of Truth
    6. Microservices
    7. Microservice Implementation Options
    8. Testing
    9. Deploying
    10. Final Words
  19. Index

Preface
    Conventions Used in This Book
    O’Reilly Online Learning
    How to Contact Us
    Acknowledgments
1. Why Event-Driven Microservices
    What Are Event-Driven Microservices?
    Introduction to Domain-Driven Design and Bounded Contexts
        Leveraging Domain Models and Bounded Contexts
        Aligning Bounded Contexts with Business Requirements
    Communication Structures
        Business Communication Structures
        Implementation Communication Structures
        Data Communication Structures
        Conway’s Law and Communication Structures
    Communication Structures in Traditional Computing
        Option 1: Make a New Service
        Option 2: Add It to the Existing Service
        Pros and Cons of Each Option
        The Team Scenario, Continued
        Conflicting Pressures
    Event-Driven Communication Structures
        Events Are the Basis of Communication
        Event Streams Provide the Single Source of Truth
        Consumers Perform Their Own Modeling and Querying
        Data Communication Is Improved Across the Organization
        Accessible Data Supports Business Communication Changes
    Asynchronous Event-Driven Microservices
        Example Team Using Event-Driven Microservices
    Synchronous Microservices
        Drawbacks of Synchronous Microservices
        Benefits of Synchronous Microservices
    Summary
2. Event-Driven Microservice Fundamentals
    Building Topologies
        Microservice Topology
        Business Topology
    The Contents of an Event
    The Structure of an Event
        Unkeyed Event
        Entity Event
        Keyed Event
    Materializing State from Entity Events
    Event Data Definitions and Schemas
    Microservice Single Writer Principle
    Powering Microservices with the Event Broker
        Event Storage and Serving
        Additional Factors to Consider
    Event Brokers Versus Message Brokers
        Consuming from the Immutable Log
        Providing a Single Source of Truth
    Managing Microservices at Scale
        Putting Microservices into Containers
        Putting Microservices into Virtual Machines
        Managing Containers and Virtual Machines
    Paying the Microservice Tax
    Summary
3. Communication and Data Contracts
    Event-Driven Data Contracts
        Using Explicit Schemas as Contracts
        Schema Definition Comments
        Full-Featured Schema Evolution
        Code Generator Support
        Breaking Schema Changes
    Selecting an Event Format
    Designing Events
        Tell the Truth, the Whole Truth, and Nothing but the Truth
        Use a Singular Event Definition per Stream
        Use the Narrowest Data Types
        Keep Events Single-Purpose
        Minimize the Size of Events
        Involve Prospective Consumers in the Event Design
        Avoid Events as Semaphores or Signals
    Summary
4. Integrating Event-Driven Architectures with Existing Systems
    What Is Data Liberation?
        Compromises for Data Liberation
        Converting Liberated Data to Events
    Data Liberation Patterns
    Data Liberation Frameworks
    Liberating Data by Query
        Bulk Loading
        Incremental Timestamp Loading
        Autoincrementing ID Loading
        Custom Querying
        Incremental Updating
        Benefits of Query-Based Updating
        Drawbacks of Query-Based Updating
    Liberating Data Using Change-Data Capture Logs
        Benefits of Using Data Store Logs
        Drawbacks of Using Data Base Logs
    Liberating Data Using Outbox Tables
        Performance Considerations
        Isolating Internal Data Models
        Ensuring Schema Compatibility
        Capturing Change-Data Using Triggers
    Making Data Definition Changes to Data Sets Under Capture
        Handling After-the-Fact Data Definition Changes for the Query and CDC Log Patterns
        Handling Data Definition Changes for Change-Data Table Capture Patterns
    Sinking Event Data to Data Stores
    The Impacts of Sinking and Sourcing on a Business
    Summary
5. Event-Driven Processing Basics
    Composing Stateless Topologies
        Transformations
        Branching and Merging Streams
    Repartitioning Event Streams
        Example: Repartitioning an Event Stream
    Copartitioning Event Streams
        Example: Copartitioning an Event Stream
    Assigning Partitions to a Consumer Instance
        Assigning Partitions with the Partition Assignor
        Assigning Copartitioned Partitions
        Partition Assignment Strategies
    Recovering from Stateless Processing Instance Failures
    Summary
6. Deterministic Stream Processing
    Determinism with Event-Driven Workflows
    Timestamps
        Synchronizing Distributed Timestamps
        Processing with Timestamped Events
    Event Scheduling and Deterministic Processing
        Custom Event Schedulers
        Processing Based on Event Time, Processing Time, and Ingestion Time
        Timestamp Extraction by the Consumer
        Request-Response Calls to External Systems
    Watermarks
        Watermarks in Parallel Processing
    Stream Time
        Stream Time in Parallel Processing
    Out-of-Order and Late-Arriving Events
        Late Events with Watermarks and Stream Time
        Causes and Impacts of Out-of-Order Events
        Time-Sensitive Functions and Windowing
    Handling Late Events
    Reprocessing Versus Processing in Near-Real Time
    Intermittent Failures and Late Events
    Producer/Event Broker Connectivity Issues
    Summary and Further Reading
7. Stateful Streaming
    State Stores and Materializing State from an Event Stream
    Recording State to a Changelog Event Stream
    Materializing State to an Internal State Store
        Materializing Global State
        Advantages of Using Internal State
        Disadvantages of Using Internal State
        Scaling and Recovery of Internal State
    Materializing State to an External State Store
        Advantages of External State
        Drawbacks of External State
        Scaling and Recovery with External State Stores
    Rebuilding Versus Migrating State Stores
        Rebuilding
        Migrating
    Transactions and Effectively Once Processing
        Example: Stock Accounting Service
        Effectively Once Processing with Client-Broker Transactions
        Effectively Once Processing Without Client-Broker Transactions
    Summary
8. Building Workflows with Microservices
    The Choreography Pattern
        A Simple Event-Driven Choreography Example
        Creating and Modifying a Choreographed Workflow
        Monitoring a Choreographed Workflow
    The Orchestration Pattern
        A Simple Event-Driven Orchestration Example
        A Simple Direct-Call Orchestration Example
        Comparing Direct-Call and Event-Driven Orchestration
        Creating and Modifying an Orchestration Workflow
        Monitoring the Orchestration Workflow
    Distributed Transactions
        Choreographed Transactions: The Saga Pattern
        Orchestrated Transactions
    Compensation Workflows
    Summary
9. Microservices Using Function-as-a-Service
    Designing Function-Based Solutions as Microservices
        Ensure Strict Membership to a Bounded Context
        Commit Offsets Only After Processing Has Completed
        Less Is More
    Choosing a FaaS Provider
    Building Microservices Out of Functions
    Cold Start and Warm Starts
    Starting Functions with Triggers
        Triggering Based on New Events: The Event-Stream Listener
        Triggering Based on Consumer Group Lag
        Triggering on a Schedule
        Triggering Using Webhooks
        Triggering on Resource Events
    Performing Business Work with Functions
    Maintaining State
    Functions Calling Other Functions
        Event-Driven Communication Pattern
        Direct-Call Pattern
    Termination and Shutdown
    Tuning Your Functions
        Allocating Sufficient Resources
        Batch Event-Processing Parameters
    Scaling Your FaaS Solutions
    Summary
10. Basic Producer and Consumer Microservices
    Where Do BPCs Work Well?
        Integration with Existing and Legacy Systems
        Stateful Business Logic That Isn’t Reliant Upon Event Order
        When the Data Layer Does Much of the Work
        Independent Scaling of the Processing and Data Layer
    Hybrid BPC Applications with External Stream Processing
        Example: Using an External Stream-Processing Framework to Join Event Streams
    Summary
11. Heavyweight Framework Microservices
    A Brief History of Heavyweight Frameworks
    The Inner Workings of Heavyweight Frameworks
    Benefits and Limitations
    Cluster Setup Options and Execution Modes
        Use a Hosted Service
        Build Your Own Full Cluster
        Create Clusters with CMS Integration
    Application Submission Modes
        Driver Mode
        Cluster Mode
    Handling State and Using Checkpoints
    Scaling Applications and Handling Event Stream Partitions
        Scaling an Application While It Is Running
        Scaling an Application by Restarting It
        Autoscaling Applications
    Recovering from Failures
    Multitenancy Considerations
    Languages and Syntax
    Choosing a Framework
    Example: Session Windowing of Clicks and Views
    Summary
12. Lightweight Framework Microservices
    Benefits and Limitations
    Lightweight Processing
    Handling State and Using Changelogs
    Scaling Applications and Recovering from Failures
        Event Shuffling
        State Assignment
        State Replication and Hot Replicas
    Choosing a Lightweight Framework
        Apache Kafka Streams
        Apache Samza: Embedded Mode
    Languages and Syntax
    Stream-Table-Table Join: Enrichment Pattern
    Summary
13. Integrating Event-Driven and Request-Response Microservices
    Handling External Events
        Autonomously Generated Events
        Reactively Generated Events
    Handling Autonomously Generated Analytical Events
    Integrating with Third-Party Request-Response APIs
    Processing and Serving Stateful Data
        Serving Real-Time Requests with Internal State Stores
        Serving Real-Time Requests with External State Stores
    Handling Requests Within an Event-Driven Workflow
        Processing Events for User Interfaces
    Micro-Frontends in Request-Response Applications
    The Benefits of Microfrontends
        Composition-Based Microservices
        Easy Alignment to Business Requirements
    Drawbacks of Microfrontends
        Potentially Inconsistent UI Elements and Styling
        Varying Microfrontend Performance
        Example: Experience Search and Review Application
    Summary
14. Supportive Tooling
    Microservice-to-Team Assignment System
    Event Stream Creation and Modification
    Event Stream Metadata Tagging
    Quotas
    Schema Registry
    Schema Creation and Modification Notifications
    Offset Management
    Permissions and Access Control Lists for Event Streams
    State Management and Application Reset
    Consumer Offset Lag Monitoring
    Streamlined Microservice Creation Process
    Container Management Controls
    Cluster Creation and Management
        Programmatic Bringup of Event Brokers
        Programmatic Bringup of Compute Resources
        Cross-Cluster Event Data Replication
        Programmatic Bringup of Tooling
    Dependency Tracking and Topology Visualization
        Topology Example
    Summary
15. Testing Event-Driven Microservices
    General Testing Principles
    Unit-Testing Topology Functions
        Stateless Functions
        Stateful Functions
    Testing the Topology
    Testing Schema Evolution and Compatibility
    Integration Testing of Event-Driven Microservices
    Local Integration Testing
        Create a Temporary Environment Within the Runtime of Your Test Code
        Create a Temporary Environment External to Your Test Code
        Integrate Hosted Services Using Mocking and Simulator Options
        Integrate Remote Services That Have No Local Options
    Full Remote Integration Testing
        Programmatically Create a Temporary Integration Testing Environment
        Testing Using a Shared Environment
        Testing Using the Production Environment
    Choosing Your Full-Remote Integration Testing Strategy
    Summary
16. Deploying Event-Driven Microservices
    Principles of Microservice Deployment
    Architectural Components of Microservice Deployment
        Continuous Integration, Delivery, and Deployment Systems
        Container Management Systems and Commodity Hardware
    The Basic Full-Stop Deployment Pattern
    The Rolling Update Pattern
    The Breaking Schema Change Pattern
        Eventual Migration via Two Event Streams
        Synchronized Migration to the New Event Stream
    The Blue-Green Deployment Pattern
    Summary
17. Conclusion
    Communication Layers
    Business Domains and Bounded Contexts
    Shareable Tools and Infrastructure
    Schematized Events
    Data Liberation and the Single Source of Truth
    Microservices
    Microservice Implementation Options
    Testing
    Deploying
    Final Words
Index

Sources:

Fair Use Sources:

  • B08C9V1FC9 (BEDM)
  • https://learning.oreilly.com/library/view/building-event-driven-microservices/9781492057888
Categories
Cloud DevOps Software Engineering

GitHub

Font Awesome 5 brands github.svg
GitHub logo 2013.svg
Type of businessSubsidiary
Type of siteCollaborative version control
Available inEnglish
FoundedFebruary 8, 2008; 13 years ago (as Logical Awesome LLC)
HeadquartersSan Francisco, California, United States
Area servedWorldwide
Founder(s)Tom Preston-WernerChris WanstrathP. J. HyettScott Chacon
CEONat Friedman
Key peopleMike Taylor (CFO)
IndustryCollaborative version control (GitHub)
Blog host (GitHub Pages)
Package repository (NPM)
Employees1677[1]
ParentMicrosoft
URLgithub.com 
RegistrationOptional (required for creating and joining repositories)
Users56 million (Sep 2020)
LaunchedApril 10, 2008; 12 years ago
Current statusActive
Written inRuby
ECMAScript
Go
C [2]

GitHub, Inc. is a provider of Internet hosting for software development and version control using Git. It offers the distributed version control and source code management (SCM) functionality of Git, plus its own features. It provides access control and several collaboration features such as bug trackingfeature requests, task managementcontinuous integration and wikis for every project.[3] Headquartered in California, it has been a subsidiary of Microsoft since 2018.[4]

GitHub offers its basic services free of charge. Its more advanced professional and enterprise services are commercial.[5] Free GitHub accounts are commonly used to host open-source projects.[6] As of January 2019, GitHub offers unlimited private repositories to all plans, including free accounts, but allowed only up to three collaborators per repository for free.[7] Starting from April 15, 2020, the free plan allows unlimited collaborators, but restricts private repositories to 2,000 minutes of GitHub Actions[8] per month.[9] As of January 2020, GitHub reports having over 40 million users[10] and more than 190 million repositories[11] (including at least 28 million public repositories),[12] making it the largest host of source code in the world.[13]

History

GitHub at AWS Summit

The GitHub service was developed by Chris WanstrathP. J. HyettTom Preston-Werner and Scott Chacon using Ruby on Rails, and started in February 2008. The company, GitHub, Inc., has existed since 2007 and is located in San Francisco.[14]The shading of the map illustrates the number of users as a proportion of each country’s Internet population. The circular charts surrounding the two hemispheres depict the total number of GitHub users (left) and commits (right) per country.

On February 24, 2009, GitHub announced that within the first year of being online, GitHub had accumulated over 46,000 public repositories, 17,000 of which were formed in the previous month. At that time, about 6,200 repositories had been forked at least once and 4,600 had been merged.

That same year, the site was harnessed by over 100,000 users, according to Github, and had grown to host 90,000 unique public repositories, 12,000 having been forked at least once, for a total of 135,000 repositories.[15]

In 2010, GitHub was hosting 1 million repositories.[16] A year later, this number doubled.[17] ReadWriteWeb reported that GitHub had surpassed SourceForge and Google Code in total number of commits for the period of January to May 2011.[18] On January 16, 2013, GitHub passed the 3 million users mark and was then hosting more than 5 million repositories.[19] By the end of the year, the number of repositories were twice as much, reaching 10 million repositories.[20]

In 2012, GitHub raised $100 million in funding from Andreessen Horowitz with $750 million valuation.[21] Peter Levine, general partner at Andreessen Horowitz, stated that GitHub had been growing revenue at 300% annually since 2008 “profitably nearly the entire way”.[22] On July 29, 2015, GitHub stated it had raised $250 million in funding in a round led by Sequoia Capital. Other investors of that round included Andreessen Horowitz, Thrive Capital, and IVP (Institutional Venture Partners).[23] The round valued the company at approximately $2 billion.[24]

In 2015, GitHub opened an office in Japan that is its first office outside of the U.S.[25] In 2016, GitHub was ranked No. 14 on the Forbes Cloud 100 list.[26] It has not been featured on the 2018, 2019 and 2020 lists.[27]

On February 28, 2018, GitHub fell victim to the third largest distributed denial-of-service (DDoS) attack in history, with incoming traffic reaching a peak of about 1.35 terabits per second.[28]

On June 19, 2018, GitHub expanded its GitHub Education by offering free education bundles to all schools.[29][30]

Acquisition by Microsoft

From 2012 Microsoft became a significant user of GitHub, using it to host open-source projects and development tools such as .NET CoreChakra CoreMSBuildPowerShellPowerToysVisual Studio CodeWindows CalculatorWindows Terminal and the bulk of its product documentation (now to be found on Microsoft Docs).[31][32]

On June 4, 2018, Microsoft announced its intent to acquire GitHub for US$7.5 billion. The deal closed on October 26, 2018.[33] GitHub continued to operate independently as a community, platform and business.[34] Under Microsoft, the service was led by Xamarin‘s Nat Friedman, reporting to Scott Guthrie, executive vice president of Microsoft Cloud and AI. GitHub’s CEO, Chris Wanstrath, was retained as a “technical fellow”, also reporting to Guthrie.

There have been concerns from developers Kyle Simpson, JavaScript trainer and author, and Rafael Laguna, CEO at Open-Xchange over Microsoft’s purchase, citing uneasiness over Microsoft’s handling of previous acquisitions, such as Nokia’s mobile business or Skype.[35][36]

This acquisition was in line with Microsoft’s business strategy under CEO Satya Nadella, which has seen a larger focus on the cloud computing services, alongside development of and contributions to open-source software.[37][4][32] Harvard Business Review argued that Microsoft was intending to acquire GitHub to get access to its user base, so it can be used as a loss leader to encourage use of its other development products and services.[38]

Concerns over the sale bolstered interest in competitors: Bitbucket (owned by Atlassian), GitLab (a commercial open source product that also runs a hosted service version) and SourceForge (owned by BIZX, LLC) reported that they had seen spikes in new users intending to migrate projects from GitHub to their respective services.[39][40][41][42]

In September 2019, GitHub acquired Semmle, a code analysis tool.[43] In February 2020, GitHub launched in India under the name GitHub India Private Limited.[44] In March 2020, GitHub announced that they were acquiring npm, a JavaScript packaging vendor, for an undisclosed sum of money.[45] The deal was closed on 15 April 2020.[46]

In early July 2020, the GitHub Archive Program was established, to archive its open source code in perpetuity.[47]

Services

GitHub.com

Development of the GitHub.com platform began on October 19, 2007.[60][61][62] The site was launched in April 2008 by Tom Preston-Werner, Chris Wanstrath, P. J. Hyett and Scott Chacon after it had been made available for a few months prior as a beta release.[63]

Projects on GitHub.com can be accessed and managed using the standard Git command-line interface; all standard Git commands work with it. GitHub.com also allows users to browse public repositories on the site. Multiple desktop clients and Git plugins are also available. The site provides social networking-like functions such as feeds, followers, wikis (using wiki software called Gollum) and a social network graph to display how developers work on their versions (“forks“) of a repository and what fork (and branch within that fork) is newest.

Anyone can browse and download public repositories but only registered users can contribute content to repositories. With a registered user account, users are able to have discussions, manage repositories, submit contributions to others’ repositories, and review changes to code. GitHub.com began offering unlimited private repositories at no cost in January 2019 (limited to three contributors per project). Previously, only public repositories were free.[64][65][66] On April 14, 2020, GitHub made “all of the core GitHub features” free for everyone, including “private repositories with unlimited collaborators”.[67]

The fundamental software that underpins GitHub is Git itself, written by Linus Torvalds, creator of Linux. The additional software that provides the GitHub user interface was written using Ruby on Rails and Erlang by GitHub, Inc. developers Wanstrath,[68] Hyett, and Preston-Werner.

Scope

The main purpose of GitHub.com is to facilitate the version control and issue tracking aspects of software development. Labels, milestones, responsibility assignment, and a search engine are available for issue tracking. For version control, Git (and by extension GitHub.com) allows pull requests to propose changes to the source code. Users with the ability to review the proposed changes can see a diff of the requested changes and approve them. In Git terminology, this action is called “committing” and one instance of it is a “commit”. A history of all commits are kept and can be viewed at a later time.

In addition, GitHub supports the following formats and features:

  • Documentation, including automatically rendered README files in a variety of Markdown-like file formats (see README § On GitHub)
  • Wikis
  • GitHub Actions, which allows building continuous integration and continuous deployment pipelines for testing, releasing and deploying software without the use of third-party websites/platforms
  • Graphs: pulse, contributors, commits, code frequency, punch card, network, members
  • Integrations Directory[69]
  • Email notifications
  • Discussions
  • Option to subscribe someone to notifications by @ mentioning them.[70]
  • Emojis[71]
  • Nested task-lists within files
  • Visualization of geospatial data
  • 3D render files that can be previewed using a new integrated STL file viewer that displays the files on a “3D canvas”.[72] The viewer is powered by WebGL and Three.js.
  • Photoshop’s native PSD format can be previewed and compared to previous versions of the same file.
  • PDF document viewer
  • Security Alerts of known Common Vulnerabilities and Exposures in different packages

GitHub’s Terms of Service do not require public software projects hosted on GitHub to meet the Open Source Definition. The terms of service state, “By setting your repositories to be viewed publicly, you agree to allow others to view and fork your repositories.”[73]

GitHub Enterprise

GitHub Enterprise is a self-managed version of GitHub.com with similar functionality. It can be run on an organization’s own hardware or on a cloud provider, and it has been available since November 2011.[74] In November 2020, source code for GitHub Enterprise Server was leaked online in apparent protest against DMCA takedown of YouTube-dl. According to GitHub, the source code came from GitHub accidentally sharing the code with Enterprise customers themselves, not from an attack on GitHub servers.[75][76]

GitHub Pages

GitHub Pages is a static web hosting service offered by GitHub since 2008 to GitHub users for hosting user blogs, project documentation,[77][78] or even whole books created as a page.[79]

All GitHub Pages content is stored in a Git repository, either as files served to visitors verbatim or in Markdown format. GitHub is seamlessly integrated with Jekyll static web site and blog generator and GitHub continuous integration pipelines. Each time the content source is updated, Jekyll regenerates the website and automatically serves it via GitHub Pages infrastructure.[80]

As with the rest of GitHub, it includes both free and paid tiers of service, instead of being supported by web advertising. Web sites generated through this service are hosted either as subdomains of the github.io domain, or as custom domains bought through a third-party domain name registrar.[81] When custom domain is set on a GitHub Pages repo a Let’s Encrypt certificate for it is generated automatically. Once the certificate has been generated Enforce HTTPS can be set for the repository’s website to transparently redirect all HTTP requests to HTTPS.[82][83]

Gist

GitHub also operates other services: a pastebin-style site called Gist[63] that is for hosting code snippets (GitHub proper is for hosting larger projects).

Tom Preston-Werner presented the then-new Gist feature at a punk rock Ruby conference in 2008.[84] Gist builds on the traditional simple concept of a pastebin by adding version control for code snippets, easy forking, and TLS encryption for private pastes. Because each “gist” has its own Git repository, multiple code snippets can be contained in a single paste and they can be pushed and pulled using Git. Further, forked code can be pushed back to the original author in the form of a patch, so gists (pastes) can become more like mini-projects.[citation needed]

Before February 18, 2018, unregistered users were able to upload text to the site. Since then, uploading gists has been deactivated for unregistered users with the aim to mitigate spamming.[85]

Education program

GitHub launched a new program called the GitHub Student Developer Pack to give students free access to popular development tools and services. GitHub partnered with BitnamiCrowdflowerDigitalOceanDNSimpleHackHandsNamecheap, Orchestrate, Screenhero, SendGridStripeTravis CI and Unreal Engine to launch the program.[86]

In 2016 GitHub announced the launch of the GitHub Campus Experts program[87] to train and encourage students to grow technology communities at their universities. The Campus Experts program is open to university students of 18 years and older across the world.[88] GitHub Campus Experts are one of the primary ways that GitHub funds student oriented events and communities, Campus Experts are given access to training, funding, and additional resources to run events and grow their communities. To become a Campus Expert applicants must complete an online training course consisting of multiple modules designed to grow community leadership skills.

GitHub Marketplace service

GitHub also provides some software as a service integrations for adding extra features to projects. Those services include:

  • Waffle.io: Project management for software teams. Automatically see pull requests, automated builds, reviews, and deployments across all of your repositories in GitHub.
  • Rollbar: Integrate with GitHub to provide real time debugging tools and full-stack exception reporting. It is compatible with all well used code languages, such as JavaScriptPython.NETRubyPHPNode.jsAndroidiOSGoJava, and C#.
  • Codebeat: For automated code analysis specialized in web and mobile developers. The supported languages for this software are: ElixirGoJavaSwiftJavaScriptPythonRubyKotlinObjective-C, and TypeScript.
  • Travis CI: To provide confidence for your apps while doing test and ship. Also gives full control over the build environment, to adapt it to the code. Supported languages: GoJavaJavaScriptObjective-CPythonPHPRuby, and Swift.
  • GitLocalize: Developed for teams that are translating their content from one point to another. GitLocalize automatically syncs with your repository so you can keep your workflow on GitHub. It also keeps you updated on what needs to be translated.

GitHub Sponsors

GitHub Sponsors allows users to make monthly money donations to projects hosted on GitHub.[89] The public beta was announced on May 23, 2019 and currently the project accepts wait list registrations. The Verge said that GitHub Sponsors “works exactly like Patreon” because “developers can offer various funding tiers that come with different perks, and they’ll receive recurring payments from supporters who want to access them and encourage their work” except with “zero fees to use the program”. Furthermore, GitHub offer incentives for early adopters during the first year: it pledges to cover payment processing costs, and match sponsorship payments up to $5,000 per developer. Furthermore, users still can use other similar services like Patreon and Open Collective and link to their own websites.[90][91]

GitHub Archive Program

In July 2020, GitHub stored a February archive of the site[47] in an abandoned mountain mine in Svalbard, Norway, part of the Arctic World Archive and not far from the Svalbard Global Seed Vault. The archive contained the code of all active public repositories, as well as that of dormant, but significant public repositories. The 21TB of data was stored on piqlFilm archival film reels as QR codes, and is expected to last 500–1,000 years.[92][93][94][95]

The GitHub Archive Program is also working with partners on Project Silica, in an attempt to store all public repositories for 10,000 years. It aims to write archives into the molecular structure of quartz glass platters, using a high-precision laser that pulses a quadrillion (1,000,000,000,000,000) times per second.[95]

Developed projects

  • Atom, a free and open-source text and source code editor
  • Electron, an open-source framework to use JavaScript-based websites as desktop applications.

Prominent users

Some prominent open source organizations and projects use GitHub as a primary place for collaboration, including:

See also

Categories

” (WP)

Sources:

Fair Use Sources:

Categories
Artificial Intelligence AWS Azure Bibliography C Language C# .NET C++ Cloud Data Science - Big Data DevOps DevSecOps-Security-Privacy Django Web Framework Flask Web Framework GCP Go Programming Language Java JavaScript Kotlin Kubernetes Linux Networking Operating Systems PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript Windows Server

Udemy

See Dr. Angela Yu, Udemy’s best instructor: 100 Days of Code – The Complete Python Pro Bootcamp

Udemy, Inc. is an American massive open online course (MOOC) provider aimed at professional adults and students. It was founded in May 2010 by Eren Bali, Gagan Biyani, and Oktay Caglar.

As of February 2021, the platform has more than 40 million students, 155,000 courses and 70,000 instructors teaching courses in over 65 languages. There have been over 480 million course enrollments. Students and instructors come from 180+ countries and 2/3 of the students are located outside of the U.S.[3]

Students take courses largely as a means of improving job-related skills.[4] Some courses generate credit toward technical certification. Udemy has made a special effort to attract corporate trainers seeking to create coursework for employees of their company.[5] As of 2021, there are more than 155,000 courses on the website.[6][3]

The headquarters of Udemy is located in San Francisco, California, with offices in Denver, Colorado; Dublin, Ireland; Ankara, Turkey; Sao Paulo, Brazil; and Gurugram, India.[7]

(WP)

Sources:

Fair Use Sources:

Categories
Bibliography Data Science - Big Data DevOps Python Software Engineering

Python Bibliography

See also: Python and Bibliography of Python Libraries and Web Frameworks, Python Programming Courses

  1. Python Software Foundation Documentation (PSFDoc)
  2. GitHub (GH)
  3. Wikipedia (WP)
  4. 100 Days of Code – The Complete Python Pro Bootcamp, by Dr. Angela Yu (100PyAYu)
  5. The Python 3 Standard Library by Example, by Doug Hellmann, B072QZZDV7 (P3SLbE)
  6. Python Pocket Reference: Python In Your Pocket, by Mark Lutz, B00HZ41PGC (PPR)
  7. Head First Python: A Brain-Friendly Guide, by Paul Barry, B01N0GU0OC (HFPy)
  8. The Well-Grounded Python Developer, by Doug Farrell, 2021, 1617297441 (WlGrPD)
  9. Learning Python: Powerful Object-Oriented Programming, by Mark Lutz, B00DDZPC9S (LPMkLz)
  10. Programming Python: Powerful Object-Oriented Programming, by Mark Lutz, B004GTLFJ6 (PPMkLz)
  11. Python Crash Course: A Hands-On, Project-Based Introduction to Programming, by Eric Matthes, B07J4521M3 (PyCrCs)
  12. Introducing Python: Modern Computing in Simple Packages, by Bill Lubanovic, 2020, B0815R5543 (IPyBLub)
  13. Practices of the Python Pro, by Dane Hillard, 2020, 1617296082 (PrPyPro)
  14. Think Python: How to Think Like a Computer Scientist, by Allen B. Downey, B018UXJ9EQ (ThnkPy)
  15. Python in a Nutshell: A Desktop Quick Reference, 3rd Edition, by Alex Martelli, Anna Ravenscroft, and Steve Holden, 2017, B06Y4DVSBM (PyNutSh)
  16. The Quick Python Book, by N. Ceder, 1617294039 (QPB)

Categories
C++ Cloud DevOps DevSecOps-Security-Privacy Software Engineering

Design Patterns: Elements of Reusable Object-Oriented Software, Gang of Four (GoF), 1994

See also: Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software, 2nd Edition, by Eric Freeman and Elisabeth Robson, 2021

Fair Use Source: B000SEIBB8 (GoF)

Design Patterns: Elements of Reusable Object-Oriented Software, 1st Edition, by Gamma Erich, Helm Richard, Johnson Ralph, Vlissides John

Design Patterns: Elements of Reusable Object-Oriented Software (1994) is a software engineering book describing software design patterns. The book was written by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, with a foreword by Grady Booch. The book is divided into two parts, with the first two chapters exploring the capabilities and pitfalls of object-oriented programming, and the remaining chapters describing 23 classic software design patterns. The book includes examples in C++ and Smalltalk.” (WP)

“It has been influential to the field of software engineering and is regarded as an important source for object-oriented design theory and practice. More than 500,000 copies have been sold in English and in 13 other languages. The authors are often referred to as the Gang of Four (GoF).[1]” (WP)

Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves.

The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently.

Each pattern describes the circumstances in which it is applicable, when it can be applied in view of other design constraints, and the consequences and trade-offs of using the pattern within a larger design. All patterns are compiled from real systems and are based on real-world examples. Each pattern also includes code that demonstrates how it may be implemented in object-oriented programming languages like C++ or Smalltalk.

Editorial Reviews

Design Patterns is a modern classic in the literature of object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of code. Note, though, that it’s not a tutorial but a catalog that you can use to find an object-oriented design pattern that’s appropriate for the needs of your particular application–a selection for virtuoso programmers who appreciate (or require) consistent, well-engineered object-oriented designs

Book Details

  • ASIN: B000SEIBB8
  • Publisher: Addison-Wesley Professional; 1st edition (October 31, 1994)
  • Publication date: October 31, 1994
  • Print length: 568 pages

Sources:

Fair Use Sources:

Categories
Cloud DevOps DevSecOps-Security-Privacy Software Engineering

Head First Design Patterns

See also: Design Patterns: Elements of Reusable Object-Oriented Software, Gang of Four (GoF), 1994

Fair Use Source: B08P3X99QP (HFDP)

See: Head First Design Patterns: Building Extensible and Maintainable Object-Oriented Software, 2nd Edition, by Eric Freeman and Elisabeth Robson, Kathy Sierra, and Bert Bates, 2021

What will you learn from this book?

You know you don’t want to reinvent the wheel, so you look to Design Patterns: the lessons learned by those who’ve faced the same software design problems. With Design Patterns, you get to take advantage of the best practices and experience of others so you can spend your time on something more challenging. Something more fun. This book shows you the patterns that matter, when to use them and why, how to apply them to your own designs, and the object-oriented design principles on which they’re based. Join hundreds of thousands of developers who’ve improved their object-oriented design skills through Head First Design Patterns.

What’s so special about this book?

If you’ve read a Head First book, you know what to expect: a visually rich format designed for the way your brain works. With Head First Design Patterns, 2E you’ll learn design principles and patterns in a way that won’t put you to sleep, so you can get out there to solve software design problems and speak the language of patterns with others on your team.

Book Details

  • ASIN: B08P3X99QP
  • ISBN: 978-1-492-07800-5
  • Publisher: O’Reilly Media; 2nd edition (November 24, 2020)
  • Publication date: November 24, 2020
  • Print length: 1156 pages
  • Printing History: October 2004: First edition
  • December 2020: Second edition
  • Release History: 2020-11-10 First release

Dedication:

“To the Gang of Four, whose insight and expertise in capturing and communicating Design Patterns has changed the face of software design forever, and bettered the lives of developers throughout the world. But seriously, when are we going to see a second edition? After all, it’s been only twenty-five years.” (HFDP)

” (HFDP)

Sources:

Fair Use Sources:

Categories
C Language C# .NET C++ Cloud DevOps Django Web Framework Flask Web Framework Go Programming Language Java JavaScript Kotlin PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript

Software design pattern

In software engineering, a software design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design. It is not a finished design that can be transformed directly into source or machine code. Rather, it is a description or template for how to solve a problem that can be used in many different situations. Design patterns are formalized best practices that the programmer can use to solve common problems when designing an application or system.

Object-oriented design patterns typically show relationships and interactions between classes or objects, without specifying the final application classes or objects that are involved. Patterns that imply mutable state may be unsuited for functional programming languages, some patterns can be rendered unnecessary in languages that have built-in support for solving the problem they are trying to solve, and object-oriented patterns are not necessarily suitable for non-object-oriented languages.

Design patterns may be viewed as a structured approach to computer programming intermediate between the levels of a programming paradigm and a concrete algorithm.

In a recent review study, Wedyan and Abufakher investigate design patterns and software quality and conclude: “Our study has shown that the primary studies provide an empirical evidence on the positive effect of documentation of designs pattern instances on program comprehension, and therefore, maintainability. While this result is not surprising, it has, however, two indications. First, developers should pay more effort to add such documentation, even if in the form of simple comments in the source code. Second, when comparing results of different studies, the effect of documentation has to be considered.”[1]

Categories
Cloud DevOps DevSecOps-Security-Privacy Software Engineering

! Template Design Pattern

” (GoF)

” (WP)

Sources:

Fair Use Sources:

Categories
C Language C# .NET C++ Cloud Data Science - Big Data DevOps Django Web Framework Flask Web Framework Go Programming Language Java JavaScript Kotlin PowerShell Python Ruby Software Engineering Spring Framework Swift TypeScript

Integrated Development Environment (IDE)

“An integrated development environment (IDE) is a software application that provides comprehensive facilities to computer programmers for software development. An IDE normally consists of at least a source code editorbuild automation tools and a debugger. Some IDEs, such as Visual Studio, NetBeans and Eclipse, contain the necessary compilerinterpreter, or both; others, such as SharpDevelop and Lazarus, do not.” (WP)

“The boundary between an IDE and other parts of the broader software development environment is not well-defined; sometimes a version control system or various tools to simplify the construction of a graphical user interface (GUI) are integrated. Many modern IDEs also have a class browser, an object browser, and a class hierarchy diagram for use in object-oriented software development.” (WP)

Categories
Cloud DevOps Linux Operating Systems

Kubuntu Linux Operating System

Official websitekubuntu.org
Kubuntu logo and wordmark.svg

Kubuntu (/kʊˈbʊntuː/ kuu-BUUN-too)[4] is an official flavour of the Ubuntu Linux distribution operating system that uses the KDE Plasma Desktop instead of the GNOME desktop environment. As part of the Ubuntu project, Kubuntu uses the same underlying systems. Every package in Kubuntu shares the same repositories as Ubuntu,[5] and it is released regularly on the same schedule as Ubuntu.[6]

Kubuntu was sponsored by Canonical Ltd. until 2012 and then directly by Blue Systems. Now, employees of Blue Systems contribute upstream, to KDE and Debian, and Kubuntu development is led by community contributors. During the changeover, Kubuntu retained the use of Ubuntu project servers and existing developers.[7]

Kubuntu was born on 10 December 2004 at the Ubuntu Mataro Conference in Mataró, Spain.

(WP)

Sources:

Fair Use Sources:

Categories
Cloud DevOps Linux Operating Systems

Linux Mint Operating System

Linux Mint Official Logo.svg
Official websitelinuxmint.com

Linux Mint is a community-driven Linux distribution based on Ubuntu which itself is based on Debian, and bundled with a variety of free and open-source applications.[5][6] It can provide full out-of-the-box multimedia support for those who choose (by ticking one box during its installation process) to include proprietary software such as multimedia codecs.[7]

The Linux Mint project was created by Clément Lefèbvre and is actively maintained by the Linux Mint Team and community.[8]

Linux Mint began in 2006 with a beta release, 1.0, code-named ‘Ada’,[9] based on Kubuntu. Linux Mint 2.0 ‘Barbara’ was the first version to use Ubuntu as its codebase. It had few users until the release of Linux Mint 3.0, ‘Cassandra’.[10][11]

(WP)

Sources:

Fair Use Sources:

Categories
Cloud DevOps Linux Operating Systems

Ubuntu Linux Operating System

Logo-ubuntu no(r)-black orange-hex.svg

Ubuntu (/ʊˈbʊntuː/ (listenuu-BUUN-too)[7] is a Linux distribution based on Debian and composed mostly of free and open-source software.[8][9][10] Ubuntu is officially released in three editions: Desktop,[11] Server,[12] and Core[13] for Internet of things devices[14] and robots.[15][16] All the editions can run on the computer alone, or in a virtual machine.[17] Ubuntu is a popular operating system for cloud computing, with support for OpenStack.[18] Ubuntu’s default desktop has been GNOME, since version 17.10.[19]

Ubuntu is released every six months, with long-term support (LTS) releases every two years.[7][20][21] As of 22 October 2020, the most recent long-term support release is 20.04 (“Focal Fossa”), which is supported until 2025 under public support and until 2030 as a paid option. The latest standard release is 20.10 (“Groovy Gorilla”), which is supported for nine months.

Ubuntu is developed by Canonical,[22] and a community of other developers, under a meritocratic governance model.[7][23] Canonical provides security updates and support for each Ubuntu release, starting from the release date and until the release reaches its designated end-of-life (EOL) date.[7][24][25] Canonical generates revenue through the sale of premium services related to Ubuntu.[26][27]

Ubuntu is named after the Nguni philosophy of ubuntu, which Canonical indicates means “humanity to others” with a connotation of “I am what I am because of who we all are”.[7]

(WP)

Sources:

Fair Use Sources: