Requisites

Foundations of computating

Mathematical foundations

Engineering foundations

System foundations

Resources

Introduction

What is software?

Software is the information that users provide to a computer. Some examples are images, music, instructions, and so on.

Complexity

Software disciplines

Process software

Why does software engineering matter to you?

Today is easy making a web, it doesn’t need all software engineering to do it, but some projects are critical such as

https://www.researchgate.net/profile/David-Parnas/publication/242413466_Assessment_of_safety-critical_software_in_nuclear_power_plants/links/55956a6508ae99aa62c72619/Assessment-of-safety-critical-software-in-nuclear-power-plants.pdf

Since you program over time —when you contribute to building a large system, you design, construct software reasonably efficiently and correctly, and whose code can be maintained and reused you must do software engineering otherwise failure increases exponentially.

Buying and using versus building solutions

Warning. Buzzwords and Marketing.

Today we live in Babel Tower, but software engineering is even worse, you should choose carefully who listens. Why? …

Since disciplines are process-independent, requirements, design, construction, and others, have to.

What is kind of software going to build? Software applications

By Functionality

• Basic software. Compilers, Operating systems, Networking.

• Basic Management.

• Military.

By business model.

• Product in Enterprise.

• Product in Startup.

• Consultant.

• Government.

• Military.

• Internal IT department.

• Research.

• Open-source. https://www.youtube.com/watch?v=qs_xS1Y6nGc&ab_channel=GoogleOpenSource The Cathedral and the Bazaar

Some people call the Software factory their job, is it accurate?

https://www.quora.com/Why-did-software-factories-not-become-a-standard-way-to-develop-software

https://www.youtube.com/watch?v=NbqDeHj2Jm4&ab_channel=SoftwareEngineeringInstitute|CarnegieMellonUniversity

Software arquitectechts

Software engineers

By safety integrity level. IEC 61508

• Safety-Critical Software

https://dev.to/bosepchuk/safety-critical-software-15-things-every-developer-should-know-1kdh

Research

https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=52

Software layers

Key concepts. Vocabulary.

Products vs. tools vs. platforms vs. ecosystems.

Toolchain.

Framework.

Library.

Since we’re working in the Engineering field and we have to avoid the Tower of Babel, you have got to use standards for qualified authority.

ISO/IEC/IEEE 24765 Systems and software engineering — Vocabulary

CMMI

Story

https://www.youtube.com/watch?v=QUz10Z1AfLc&ab_channel=AssociationforComputingMachinery(ACM)

https://www.youtube.com/watch?v=-3yFBlR2o-o&ab_channel=CodeLab

https://www.youtube.com/watch?v=-hnguwVg-iE&ab_channel=BuildStuff

FAQ

Worked examples

Domain understanding

Zero Footprint Applications

https://blog.pragmaticengineer.com/the-product-minded-engineer/

https://programmingisterrible.com/post/139222674273/write-code-that-is-easy-to-delete-not-easy-to

Language problem.

Needfinding.

Prototypes.

Process centered on the user.

Before anything, we must understand the user domain, and how it really solves their needs.

Four situations. Known known. Known unknown. Unknown known. Unknown unknown.

Maker dilemma

Decision table

UML

Decision tree

FAQ

Product companies

https://www.youtube.com/watch?v=Vjpu_P-LHTo&ab_channel=BlancaflorArada

Software requirements

Notes

Worked examples

Performance

https://blog.nelhage.com/post/reflections-on-performance/

FAQ

Further resources

https://datatracker.ietf.org/doc/html/rfc2119

Contracts, scenarios, and prototypes. An integrated approach to high-quality software by Reinhold Plösch.

Software design. System design.

Office, C. D. a. D. (2019). Government Design Principles. GOV. Retrieved from https://www.gov.uk/guidance/government-design-principles?mc_cid=b8b24095f3&mc_eid=541175b307

Principles

First software design principle. At least you don’t have a good reason, use the available software. In real life, don’t make another programming language, javascript framework, browser, or whatever if you don’t have to.

• Common case fast.

• Follow community standards and institutional standards.

• Small is beautiful. Simple is beautiful.

• Focus on marginal costs.

• SOLID.

echo "1"

Choosing boring technologies. https://mcfunley.com/choose-boring-technology

Computers can be understood. https://blog.nelhage.com/post/computers-can-be-understood/

DRY vs The Wrong abstraction. https://www.sandimetz.com/blog/2016/1/20/the-wrong-abstraction

Falsehoods programmers believe about names. https://www.kalzumeus.com/2010/06/17/falsehoods-programmers-believe-about-names/

http://web.mit.edu/Saltzer/www/publications/endtoend/endtoend.pdf

Enterprise architecture

Warning

• Some software should not be built in OOP.

Model-driven engineering

https://www.youtube.com/watch?v=3aoLV5i1feo&t=3s&ab_channel=Computerphile

Conventions and standards

Unless you have good reasons, follow them —your taste is not a good reason.

Some standards

https://google.github.io/styleguide/cppguide.html

Reactive programming

Redux

Security

SAML 2.0

openldap

OOP

Design Patterns: Elements of Reusable Object-Oriented Software. Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides y Grady Booch.

https://savvily.es/libros/codigo-sostenible/

Tradeoffs

Inherit

By market

API

https://blog.keras.io/user-experience-design-for-apis.html

Tools

https://plantuml.com/

System design

https://bytebytego.com/

Jeffrey Dean – Google Research. (2022, August 18). Retrieved from https://research.google/people/jeff

Low-Code and No-Code Development

Will Low-Code and No-Code Development Replace Traditional Coding? - Slashdot. (2022, September 18). Retrieved from https://developers.slashdot.org/story/22/09/18/1624258/will-low-code-and-no-code-development-replace-traditional-coding

Tools

1. Budibase

2. Zapier

3. IFTTT

4. Airtable

5. Typeform

6. Shopify

7. Webflow

8. Carrd

9. Payhere

10. Stripe

11. Memberstack

12. Voiceflow

13. https://lottiefiles.com/

The NoCode.Tech Tools Directory. (2022, November 03). Retrieved from https://www.nocode.tech/tools

SVGator: Free SVG Animation Creator Online - No Coding. (2022, November 01). Retrieved from https://www.svgator.com

https://github.com/SVG-Edit/svgedit

https://github.com/steven2358/awesome-generative-ai

Libraries for typical software

B2B Apps

React Admin

https://github.com/UgnisSoftware/react-spreadsheet-import

https://github.com/swsvindland/opentable-react

https://github.com/FancyGrid/awesome-grid

Package manager and dependencies

https://en.wikipedia.org/wiki/Package_manager

composer update --lock

npm install --save-exact

Dependency hell

Dependency resolution

Modules

https://docs.laravelmodules.com/v10/introduction

Key Management System

Communicational protocols

Concurrency

Distributed systems

Notion - The all-in-one workspace for your notes, tasks, wikis, and databases.

A new tool that blends your everyday work apps into one. It's the all-in-one workspace for you and your team

https://www.notion.so/sanchezcarlosjr/Telecommunications-87e5ae53e99a4d6382e4d1f853d7f5dahttps://www.notion.so/sanchezcarlosjr/Telecommunications-87e5ae53e99a4d6382e4d1f853d7f5dahttps://www.notion.so/sanchezchttps://www.notion.so/sanchezcarlosjr/Telecommunications-87e5ae53e99a4d6382e4d1f853d7f5daarlosjr/Telecommunications-87e5ae53e99a4d6382e4d1f853d7f5da

Distributed systems: Principles and Paradigms. Andrew S. Tanenbaum

https://www.distributed-systems.net

https://blog.pragmaticengineer.com/system-design-interview-an-insiders-guide-review/

References

The Design of Design: Essays from a Computer Scientist. Frederick P. Jr. Brooks. 2010. Addison-Wesley Professional.

Software construction

Software implementation? Programming? Coding?

Code Complete: A Practical Handbook of Software Construction. Steve McConnell.

Code: The Hidden Language of Computer Hardware and Software. Charles Petzold.

Structured programming. Dijkstra.

Literate programming

Efficiency

Ecosystem

Metaprogramming

Checkpoint/Restart and Application checkpointing

https://cvw.cac.cornell.edu/Checkpoint/

https://criu.org/Main_Page

https://gist.github.com/sanchezcarlosjr/3d1501d01e87a2eee7ffcabe20b0bc0e

Storage

RAID

Collaborative work

Git

Subversion

GitHub flow

Git

GitLab flow

Release flow

Trunk-based development

Master-only flow (One Flow)

IDE and editors

VIM

References

6.005: Software Construction. (2020, August 06). Retrieved from https://web.mit.edu/6.005/www/sp16

6.031: Software Construction. (2022, May 23). Retrieved from https://web.mit.edu/6.031/www/sp22

Programming-from-A.-to-Z. "A2Z-F16." GitHub, 23 Jan. 2023, github.com/Programming-from-A-to-Z/A2Z-F16/blob/gh-pages/README.md.

Software maintenance

https://programmingisterrible.com/post/139222674273/write-code-that-is-easy-to-delete-not-easy-to

https://programmingisterrible.com/post/176657481103/repeat-yourself-do-more-than-one-thing-and

Software metric

• ABC Software Metric

• Balanced scorecard

• Bugs per line of code

• Code coverage

• Cohesion

• Comment density

  [3]

• Connascent software components

• Constructive Cost Model

• Coupling

• Cyclomatic complexity (McCabe's complexity)

• Cyclomatic complexity density

  [4]

  [5]

• Defect density - defects found in a component

• Defect potential - expected number of defects in a particular component

• Defect removal rate

• DSQI (design structure quality index)

• Function Points and Automated Function Points, an Object Management Group standard

  [6]

• Halstead Complexity

• Instruction path length

• Maintainability index

• Source lines of code - number of lines of code

• Program execution time

• Program load time

• Program size (binary)

• Weighted Micro Function Points

• Cycle time (software)

• First pass yield

• Corrective Commit Probability

  [7]

Entropy. Technical debt.

Documentation

How can you build useful documentation that can be hard to maintain?

Famous or interesting documentation

https://www.gnu.org/software/parallel/parallel.html#EXAMPLE:-Working-as-xargs--n1.-Argument-appending

man(1) - Linux manual page. (2022, September 26). Retrieved from https://man7.org/linux/man-pages/man1/man.1.html

Tools

plantuml

markdown

asciidoc

pandadoc

tag cloud

Backups

https://wiki.nikiv.dev/backups/

System Reference Manual

https://guides.lib.berkeley.edu/how-to-write-good-documentation

https://twitter.com/gunnarmorling/status/1566487233703583748

Developer Reference Manual

Firebase API Reference. (2022, September 21). Retrieved from https://firebase.google.com/docs/reference

Angular - Introduction to the Angular Docs. (2022, March 09). Retrieved from https://angular.io/docs

https://shalvah.teachable.com/p/api-documentation-for-developers

• SmartBear's The State of API 2019 [PDF]

• Postman's 2020 State of the API Report

End User System Reference Manual

In some countries, you have got to write an end user, but some UX practices recommend avoiding it because nobody read it, you should develop an easy-to-use system instead.

Deprecation

Software configuration management

Build system

MakeT

Cmake

https://www.youtube.com/watch?v=mWOmkwv8N_U

Ninja

Vite, Webpack and Gulp

Software engineering management

Predictions and estimating

Culture, peopleware

Models

Capability Maturity Model Integration

Further resources

Software engineering models and methods

Software quality

Plösch, R. (2004). Contracts and Scenarios in the Software Development Process. In: Contracts, Scenarios and Prototypes. Springer, Berlin, Heidelberg. https://libcon.rec.uabc.mx:4440/10.1007/978-3-642-18564-9_6

Applied software measurement. Capers Jones.

The Economics of Software Quality. Capers Jones.

Structured programming

Style guides and rules

Code review

Documentation

Markdown

Bugs. Defects in systems.

https://www.youtube.com/watch?v=606Vxh-jQZY

heisenbugs

Heisenbug

https://www.youtube.com/watch?v=GX3URhx6i2E

Quality assurance

The project has got to verify and validate its result in order to give some quality and security where “validation” means “are we building the right product?” and “verification” means “are we building the product right?” or formally according to [1]:

“Verification” is the process of evaluating a system to satisfy requirements.

“Validation” is evaluating a system to satisfy intended use or meet the customer’s expectations.

In the former, you check if your software meets functional and non-functional requirements —technical scope. The last, you check if your software is useful to your stakeholders or fits their purposes —the software’s economic value.

In those checking processes or, in short, the “V&V” process, the level of confidence depends on, first of all, software criticalness, user expectations, and the external environment such as marketing, industry, and law.

You must consider that “V&V” processes are not standard but industry based. Each organization chooses what are their engineering practices, therefore, the checking process. Our goal is to describe them to you.

You could be asking yourself “why I should check my software?”. The answer is that you need feedback since you don’t what are your customers expect or whether the system satisfies their requirements. However, a tradeoff is which techniques you have got to do in order to achieve good feedback from your customers and your system and how much cost it.

Related work

The project lives in a technology ecosystem, a set of technology units (software, services, hardware, …) interacting with each other, that serves as a common technical platform to choose the most convenient tools to verify and validate our project at time and cost-efficient.

Our stakeholders work in an industry that constrains our system and their engineering practices, i.e. our verification and validation tools. We consider the development process or methodology an engineering practice or specifically a software engineering practice.

Quality and security are really concerned about the “V&V” process because it gives some guarantee system is free from defects, satisfies implicit and explicit requirements, and has strong security features.

Examples are bootstrapping startups web-based that validate over the market, it verifies little and nothing. Another hand, a military system to manage submarine nuclear weapons by the Department of Defense has got to be verified and validated really stronger, and of course, with other tools and engineering practices [5].

How do you verify and validate systems?

It depends on your engineering practices, specifically your development process. The waterfall process checks at the end of the project so you might have a plan and do it [7] while the agile process checks software units after they are ready and big product companies check based on marketing decisions —roughly speaking, years of development with verification and after the first release daily validation—.

Because we want to be free of the development process and other circumstances, first off we present the techniques, strategies, and processes to check your system. After we use them to make up politics, guidelines, and plans by industry, development process, and software ecosystem.

Checking dimensions

When you check your software, you are defining what is subject under test (SUT) and what it checking approach is.

You must not reinvent the wheel, authors and industry define different dimensions for every checking process.

Size

Since we're looking to isolate errors or check what works, you constrain the checking process by deterministic and speed. When size grows, restrictions are relaxed, but of course, the probability of something going wrong increases too.

Small. The checking process must run in a single process (single thread), they can’t run a third-party program, sleep, perform I/O operations, or make any other blocking calls. When SUT relies on them, you must replace them with doubles.

Medium. It can span multiple processes, and threads, and can make blocking calls, including network calls locally but isn’t allowed external network calls.

Large. It removes the external network call restriction.

Scope

Unit. It verifies a narrow-scoped unit such as an individual class or method being developed.

Integration. It verifies the interaction between a small of components such as server and database.

System (e2e or functional tests). It verifies that the system meets requirements end to end.

Acceptance. It validates the system where users, customers, or other stakeholders determine whether to accept the system.

Manual Checking and Automatic Checking

Some checking processes can be automated written a code that checks if your SUT works. Is automatic testing worthy? Yes, but it has got to be higher than the tradeoff: the cost of writing this code.

Manual checking is sometimes inevitable even though we can minimize it. For example acceptance tests or debugging.

Approach

Static, dynamic, and passive checking

If you check your software when it is not running, then you are doing static checking involving a verification process [10]. In another hand, you are doing dynamic checking when the program is running involving a validation process too [10].

Passive checking means verifying without the system interaction, but with related artifacts such as logging.

The “box” approach

Boxes are really useful to understand systems. In the “V&V” process, if you know the SUT’s internal structure it is a white-box approach, if don’t know it, it is a black-box approach.

Normally, a black-box approach is a more realistic scenario than a white-box approach.

Artifacts

Since we must learn if we are doing good progress, checking strategies have objective artifacts.

Schedule

Some “V&V” strategies need a specific schedule and resource allocation in order to deploy successfully or get good feedback from customers.

People

A simplified engineering team has developers, users, and decision-makers. Those people contribute in some way to the validation and verification process.

Typically, users and decision-makers don’t program but give feedback in issue form, gives approval for decision, or cancel the project. They check your project in a black box, manual, large, and acceptance dimensions.

Developers are checking their SUT with previously read dimensions, but depends on the project and how much effort is made to assure quality.

Some teams have software quality assurance people, DevOps process, or outsourcing testing people since they have special constraints or follow special engineering practices.

Logging and issue tracking

Since we need a source from bugs, features, and other tasks, we have got to operate issue tracking and logging.

Issue-tracking software prioritizes bugs and their conditions, features, customer issues, and processes while logging is the act of recording events in order to analyze potential pitfalls, and understand defects or security issues [9].

Generally speaking, issue-tracking software and logging are lowly dependent ecosystem tools.

By the way, the defect is a more accurate name than a bug, it is the most spread term in engineering fields.

Launch approval

The maximum checking process is the launch approval and release politics: who? when? why? how?

Managers or decision makers (usually outside of the code engineering team) choose what is releasing politics and who notify.

They review significant changes in order to comply with legal requirements, security, reliability, business, privacy requirements, and so forth.

Minor changes don’t need a consultant.

Virtualization

A successful deployment only would happen if the production environment is equal to other environments such as development or preproduction. “V&V” verifies the environment since teams and organizations don’t would like a lot someone saying “But It Works On My Machine”.

Another benefit the containers and virtual machines allow continuous integration and continuous deployment. Containers, Virtual Machines, and Package Managers.

Docker

VMWare

VirtualBox

Nix https://nixos.org/

"PlanetLab | PlanetLab." 17 Nov. 2020, planetlab.cs.princeton.edu/node/1.html.

Containers

Portainer

Debugging

Debugging is a manual verification process that finds bugs confirming system behavior under determined conditions whose size and scope vary.

The most rudimentary debugging process is using temporary standard output (print, cout, printf, …) to watch the values of variables at different sites on your code and remove them. However, it is an unproductive process or they can take you to mistakes in multiprogramming environments.

A specialized debugging tool such as gdb allows you a more convenient way to print out the software’s state and understand actual system behavior. It is a highly dependent ecosystem tool, if you work on the web a debugger is integrated into browsers if you work in low-level stuff gdb is the most common, and so on and so forth.

Profiling

Profiling is a manual verification process that measures empirical memory or time from software. Like a debugger, profiling is a highly dependent ecosystem tool too.

Though we know algorithm analysis, we can observe empirical software performance using a profiling tool. But remember to follow the principle: optimize only if you have a performance requirement.

Software inspections, Peer-review, Pair testing

Software inspections, (Code) Peer-review, and Pair testing are processes of subjecting an author’s work to the scrutiny of others who are experts in the same field.

Changes are classified by size, generally speaking, are better smaller (1-30 lines) changes than bigger ones (≥300).

Verification and formal methods

We can verify our software with formal methods such as category theory, weakest precondition calculus, and so forth. The community develops languages in order to prove mathematics objects with different approaches, they are proof assistants, so they assist you to prove your SUT. Famous proof assistants are COQ, Lean, and Isabelle.

In theory, you can verify your software in whatever interactive theorem prover you want, but some clever people develop special languages such as Frama-C.

Since writing proofs is hard, proof assistants make sense when safety matters and your project doesn’t change requirements in a short time. A killer dating app doesn’t want to, a nuclear central has to.

/*@
  requires \valid(a+(0..n-1));assigns  a[0..n-1];ensures
  \forall integer i;
    0 <= i < n ==> a[i] == 0;
*/
void set_to_0(int* a, size_t n){
  size_t i;
  /*@
    loop invariant 0 <= i <= n;
    loop invariant
    \forall integer j;
      0 <= j < i ==> a[j] == 0;
    loop assigns i, a[0..n-1];
    loop variant n-i;
  */
  for(i = 0; i < n; ++i)
    a[i] = 0;
}

Logical foundations

• First order logic

• Relational calculus

• Modal logics

Analysis mechanisms

• Reduction to SAT

• Symbolic model checking

Examples

• Electronic voting

• Role-based access control

• Colour management

• File synchronization

• Radiotherapy software

• Generic naming schemes

• Undo/redo mechanisms

Languages and tools

• Alloy, Z, B, Larch, SPIN, SMV, ESC, JML, TLA+, TLAPS

Patterns of modelling and analysis

• States, invariants and operations

• Incremental state, operation splitting and views

• Declarative spec, non-determinism, frame conditions and vacuity

• Patterns for analyzing object-oriented programs

• Temporal properties: safety and liveness, deadlock and races

• Guarded commands

• Hoare triples and weakest preconditions

• Refinement, abstraction and abstract interpretation

https://groups.csail.mit.edu/sdg/6.894/syllabus.html

https://www.amazon.science/publications/using-lightweight-formal-methods-to-validate-a-key-value-storage-node-in-amazon-s3

https://www.usenix.org/conference/nsdi20/presentation/brooker

https://cacm.acm.org/magazines/2015/4/184701-how-amazon-web-services-uses-formal-methods/abstract

https://aws.amazon.com/blogs/security/automated-reasoning-and-amazon-s2n/

https://model-checking.github.io/kani-verifier-blog/2022/07/13/using-the-kani-rust-verifier-on-a-firecracker-example.html

https://github.com/ongardie/raft.tla

https://lamport.azurewebsites.net/tla/paxos-algorithm.html

https://www.amazon.science/blog/a-billion-smt-queries-a-day

https://www.amazon.science/blog/how-we-built-cedar-with-automated-reasoning-and-differential-testing

Testing tactics

Formal methods are hard, so software engineers developed automated testing where “catching bugs” is easier than debugger, adding new features, and refactoring software with confidence that any changes don't break production software.

The software industry assumes “testing” refers to automated testing, but not manual testing. Even though some techniques are applying both, it’s not a good idea to do manual testing since it doesn't allow reproducibility and doesn’t give you the same confidence levels.

Modern languages have their own testing frameworks and techniques. We’ll show you an example with a calculator in JavaScript and Jest.

Automated tests consist of Test Runner and Assertion Library. The first runs your tests, automatically detects testing code, and display results.

Example

A trivial problem is making a calculator that divides numbers.

class Calculator  {
   result = 0
   divide(a,b) {
     result = a/b
     return result
   } 
}

Now, we test it with some representative test cases.

First, the happy path, when our software works with great arguments.

test_calculator_division_when_numbers_are_not_zero() {
   // setup
   const calculator = new Calculator();
   // execution
   const result = calculator.divide(5,5);
   // validation
   expect(1).toBe(result);
}

First, the dark path, when our software works with bad arguments.

test_calculator_division_when_numbers_are_zero() {
   // setup
   const calculator = new Calculator();
   // execution
   const result = calculator.divide(5,0);
   // validation
   expect(result).toThrowError('Division by 0');
}

TDD

Previously, first, we were designing and after testing. Another way is reverse, test development driven. It allows you to do more advanced stuff such as acceptance test-driven development (ATTD) or behavior-driven development (BDD).

E2E Testing

E2E checks the whole software following the requirements.

On the web, e2e testing can be done by Selenium, Cucumber, or Cypress.

Alpha, beta testing

Alpha and beta testing are customer validation methodologies, so it means real users check immature software or get feedback from them without threatening your reputation.

They differ in the software version, amount of users, and goals.

A full reference is [12].

Security testing

Manual assessment.

Red Teams.

Vulnerability management.

SOC.

Politics, guidelines, and plans

An organization or project chooses a methodology or process that usually definites how to check your software, in the way of politics, guidelines, and plans.

Roughly speaking, more effort means more benefits. So, the effort of maintaining the strategies, politics, and plans is proportional to the quality provided for them and the software's economical value.

The checking process

The team should document their engineering practices and tools in order to assure quality. If you can do automation checking, do it. It is better to show than tell.

Some “V&V” processes need user interaction, you must follow their good practices in order to get the best feedback and validate your software efficiently.

Deployment

Deployment is a related area. How often we are checking the whole project in order to assure the project? What are their environmental conditions?

Concrete politics, guidelines, and plans

References

[1] 610.12-1990 - IEEE Standard Glossary of Software Engineering Terminology, IEEE, 1990, doi:10.1109/IEEESTD.1990.101064, ISBN 978-1-55937-067-7

[2] Henderson, Fergus. "Software engineering at Google." arXiv preprint arXiv:1702.01715 (2017).

[3] Winters, T., Manshreck, T., & Wright, H. (2020). Software engineering at google: Lessons learned from programming over time. O'Reilly Media.

[4] David G. Messerschmitt and Clemens Szyperski (2003). Software Ecosystem: Understanding an Indispensable Technology and Industry. Cambridge, MA, USA: MIT Press. ISBN 978-0-262-13432-3.

[5] Software Acquisition & Practices. (2018, October 02). Retrieved from https://innovation.defense.gov/software

[6] Sommerville, I. (2011). Software Engineering, 9/E. Pearson Education.

[7] Sommerville, I. (2007). Software Engineering, 8/E. Pearson Education.

[8] Art of Debugging with GDB, DDD, and Eclipse by Norman Matloff and Peter Jay Salzman.

[9] Gerhards, Rainer. The Syslog Protocol. doi:10.17487/RFC5424. RFC 5424.

[10] Oberkampf, W.L.; Roy, C.J. (2010). Verification and Validation in Scientific Computing. Cambridge University Press. pp. 154–5. ISBN 978-1-139-49176-1.

[11] Cem Kaner (2008), A Tutorial in Exploratory Testing (PDF)

[12] Vijay. (2022). What is Alpha Testing and Beta Testing: A Complete Guide. Software Testing Help. Retrieved from https://www.softwaretestinghelp.com/what-is-alpha-testing-beta-testing

Software testing

Manual

Debugging

bohrbug

Profiling

C ecosystem

JavaScript ecosystem

References

Art of Debugging with GDB, DDD, and Eclipse by Norman Matloff and Peter Jay Salzman.

Debugging with GDB: The GNU Source-Level Debugger by Richard Stallman, Roland Pesch, et ál.

Guide to Faster, Less Frustrating Debugging. (2002, April 04). Retrieved from https://heather.cs.ucdavis.edu/~matloff/UnixAndC/CLanguage/Debug.html

Debugging and Profiling. (2022, October 27). Retrieved from https://missing.csail.mit.edu/2020/debugging-profiling

Profiler

Testing

How Google Tests Software by James Whittaker, Jason Arbon, Jeff Carollo.

How We Test Software at Microsoft by Alan Page, Ken Johnston, and Bj Rollison

Unit testing

Test doubles

Larger testing

Floyd–Hoare logic and loop invariance

Software analyzer.

FAQ.

Should I use stdin as a testing device, debugger device, or software verification?

stdin depends on your language but some are console.log, printf …

Software deployment

Devops

Infrastructure

Continous integration

Continous deployment

Github actions

Github pages

Software Support

HelpDesk

OnCalls

On Call Principles and Protocols 6th Edición de Shane A. Marshall MD FRCPC (Author), John Ruedy MDCM FRCPC LLD (hon) DMED (hon) (Author)

Rights and Duties of Software

Software is an asset

Ethics

https://www.youtube.com/watch?v=9vz06QO3UkQ&ab_channel=moviemaniacsDE

Further readings

Gift of Fire, A: Social, Legal, and Ethical Issues for Computing Technology by Sara Baase, Timothy Henry.

Blueprint for an AI Bill of Rights - The White House. (2022, October 04). Retrieved from https://www.whitehouse.gov/ostp/ai-bill-of-rights

https://mailtrap.io/

Legal aspects of computing

Contracts

The business model, license model, and process development determine how you write contracts.

Lavesson, N., Boldt, M., Davidsson, P. et al. Learning to detect spyware using end user license agreements.

Knowl Inf Syst 26, 285–307 (2011). https://libcon.rec.uabc.mx:4440/10.1007/s10115-009-0278-z

Wideman, Max. (2003). Progressive Acquisition and the RUP

Boehm, B.W. and Ross, R. 1989. Theory-W software project management principles and examples, IEEE Transactions on Software Engineering 15(7): 902-916.

Molina-Jimenez, C., Pruyne, J., van Moorsel, A. (2005). The Role of Agreements in IT Management Software. In: de Lemos, R., Gacek, C., Romanovsky, A. (eds) Architecting Dependable Systems III. Lecture Notes in Computer Science, vol 3549. Springer, Berlin, Heidelberg. https://libcon.rec.uabc.mx:4440/10.1007/11556169_2

https://track.g2.com/resources/software-contracts?

Emam, K.E. Benchmarking Kappa: Interrater Agreement in Software Process Assessments.

Empirical Software Engineering 4, 113–133 (1999). https://libcon.rec.uabc.mx:4440/10.1023/A:1009820201126

http://www.maxwideman.com/index.htm http://www.maxwideman.com/papers/acquisition/lifecycle.htm

https://www.pmi.org/learning/library/project-contracts-decision-matrix-approach-3277

https://www.pmi.org/learning/library/project-contracts-vendor-buyer-views-7254

https://www.pmi.org/learning/library/contract-procurement-management-9101

Contract management

https://www.ibm.com/docs/en/cdfsp/7.6.1?topic=contracts-overview-software

https://docs.servicenow.com/bundle/quebec-it-service-management/page/product/asset-management/concept/c_SoftwareContracts.html

Software license agreement

Freeware

Protesware

México también apuesta por el software libre. Ley de Austeridad Republicana

Patents (intellectual property, Author Rights, copyright, copyleft)

Patents

Essential patent

Reasonable and non-discriminatory licensing —RAND and FRAND—

Copyrights

Trademarks

Open source

IP licensing

Open Data campaign

https://www.microsoft.com/en-us/legal/intellectualproperty

https://guides.library.cornell.edu/authorrights/knowyourrights

https://www.madrimasd.org/blogs/patentesymarcas/2015/los-estandares-tecnologicos-y-las-patentes-esenciales/

https://www.wipo.int/wipo_magazine/es/2019/01/article_0003.html

https://rolandwanner.com/how-to-apply-contracts-to-agile-projects/

Industry standards

https://blogs.microsoft.com/on-the-issues/2012/02/08/microsofts-support-for-industry-standards/

https://www.microsoft.com/en-us/legal/intellectualproperty/tech-licensing/support-for-industry-standards

Software licenses

Free Software

Terms of service

Privacy Policy

Politics

Pirate Party

References

Going IT Alone: The Handbook for Freelance and Contract Software Developers by Leon Brown

The Tech Contracts Handbook: Cloud Computing Agreements, Software
Licenses, and Other IT Contracts for Lawyers and Businesspeople by
David W. Tollen

https://agile-scrum.com/2018/05/18/contracts-in-agile-and-scrum/

https://agilecontracts.org/

https://en.wikipedia.org/wiki/Software_law

https://www.academia.edu/22638165/6_Contracts_and_Scenarios_in_the_Software_Development_Process

Software engineering process. Software development process. Methodologies. Software development life cycle. Software development philosophies.

Software development process in companies.

“Dogfood” projects

Big tech companies as cases study

http://steve-yegge.blogspot.com/2006/09/good-agile-bad-agile_27.html

NASA as a case study

DoD projects as a case study

Linux and Git as a case study

RUP

https://www.pmi.org/learning/library/project-management-rup-environment-8505

Agile. Scrum+XP.

https://www.youtube.com/watch?v=KJVasphi5NM&ab_channel=MasterCloudApps

What software development methodology(ies) does Google use?

Answer (1 of 3): There's one viewpoint here. But I'd like to hear other perspectives. What is Google's software development process? Here's a response from someone at Google (Amanda), in the form of a comment on the blog post that the above link eventually points to. > I've worked on waterfal...

https://www.quora.com/What-software-development-methodology-ies-does-Google-use

https://agileconsortium.pbworks.com/w/page/f/XR7+mstriebeck-ShtAddingProcess.pdf

CMMI

Examples

https://docs.google.com/document/d/1e0QTVMxo_TYzE6yfgxRs9498SYF103vW/edit#heading=h.2et92p0

References

https://www.youtube.com/watch?v=mqGSnjJBM7Y&ab_channel=MasterCloudApps

https://www.ibm.com/support/pages/rational-doors-documentation-library

https://sanchezcarlosjr.github.io/software-engineering-master-by-escuelait/USantaTecla/5-rup/0-itinerario/index.html

Notes

Worked examples

FAQ

Further resources

Recruiting & HR

The business model makes different Recruiting & HR strategies.

Autism.

Salaries

Stock options

Remote work

International employees

https://www.youtube.com/watch?v=nD32k-LX3P8

https://www.youtube.com/watch?v=yfnJVzbKKIM

https://www.youtube.com/watch?v=PUHtFxVPSDI

https://www.youtube.com/watch?v=08OpObi8ogc

https://sockpuppet.org/blog/2015/03/06/the-hiring-post/

Software engineering professional practice?

Doc templates. Examples.

https://github.com/charliesbot/design-docs/tree/main/english

Gestor de taller mecánico AgrimManager. Documentación

Aplicación Web de Gestión de Donaciones

RUP y Arquitecturas Ágiles

https://www.youtube.com/watch?v=rLh3LBLeJ9Q&t=14s&ab_channel=CharlieL

https://bytebytego.com/courses/system-design-interview/a-framework-for-system-design-interviews

RFC

Containers awesome

• Keycloak

• Ory

• FusionAuth

• SuperTokens

https://logto.io/

https://github.com/veggiemonk/awesome-docker#networking

Project ideas

Tiny Python Projects: 21 small fun projects for Python beginners
designed to build programming skill, teach new algorithms and
techniques, and introduce software testing by Ken Youens-Clark

Classic Computer Science Problems in Python by David Kopec

TODO

Assessments

20 Questions Game on Google Assistant, Telegram and Whatsapp

Software

Disciplines

Model Domain

Languages

XML

JSON

Software management

Applications

User interaction

Since user interaction is something

Persistence

Numbers