Computing and tech
The decks are sorted by subject. Open one to see its topics and a few cards, then add it to your reviews.
580 decks · 16 subjects
Web and mobile development
72- Advanced JavaScript: classes, modules and modern syntax
- Advanced JavaScript: scope, closures and this
- Alternatives, contrast and keyboard
- ARIA roles
- Asynchronous requests in JavaScript
- Bastien and Scapin's 8 criteria
- Battery life
- CSRF vulnerabilities
- CSS positioning
- CSS selectors and specificity
- CSS units and colours
- Data binding
- Fitts's law, Hick's law and the Gestalt laws
- Flexbox
- Form validation
- From sketch to prototype
- Front-end framework: components
- Front-end framework: routing
- Front-end framework: state
- Grid
- HTML forms
- JavaScript: functions, arrays and objects
- JavaScript: variables, types and equality
- JSON
- Layout managers
- Levels A, AA and AAA
- Links and images in HTML
- Lists and tables in HTML
- Local storage on mobile
- Media queries
- Mobile interfaces and navigation
- Native, hybrid or cross-platform
- Network and offline
- Nielsen's 10 heuristics
- Password hashing
- Performance of a web application
- Permissions
- Persisting an application's data
- Personas
- Publication
- Robustness
- Routes and controllers
- Semantic elements
- Separating view and model
- Sessions and cookies
- Specifying an interface
- SQL injection
- Templates
- Testing conformance to W3C standards
- Text in HTML
- The 4 WCAG principles
- The accessibility audit
- The box model
- The catalogue of graphical components
- The CSS cascade and inheritance
- The DOM and events
- The event loop and listeners
- The lifecycle of a screen
- The master-detail interface
- The MVC pattern on the server
- The phone's sensors
- The request-response cycle
- The single-page application
- The structure of an HTML document
- Typing user input
- Typography in CSS
- Usability of a web application
- Usage scenarios
- Visualisation libraries
- Web development tools
- Web languages for data
- XSS vulnerabilities
Software engineering
71- Advanced debugging
- Anatomy of a unit test
- Automating your tests
- Behaviour-driven development
- Behavioural patterns
- Branching strategies
- Breakpoints and stepping
- Building a REST service
- Checked and unchecked exceptions
- Code coverage
- Code documentation
- Code smells
- Compile-time, run-time and logic errors
- Complex architecture patterns
- Consuming a web service
- Coupling and cohesion
- Creational patterns
- Data access: DAO, ORM, directories
- Dependency injection
- Dependency management
- Documentation and user training
- DRY, KISS, YAGNI
- Equivalence classes and boundary values
- Exchange formats: JSON, XML, CSV, YAML
- Feasibility criteria
- Functional and non-functional requirements
- Functional tests
- Git: branches and merges
- Git: rebase or merge
- Git: repository, index, commit
- Git: resolving a conflict
- Git: the basic commands
- Git: the remote repository
- Integration tests
- Layered and hexagonal architecture
- Library or framework
- Logging levels
- Merge request and review
- Modularity and packages
- MVC, MVP, MVVM
- N-tier architecture
- Reading a stack trace
- Regression tests
- Requirements elicitation
- Reverse engineering
- Review and walkthrough
- Software quality characteristics
- Specification by example
- Structural patterns
- Test doubles
- Test-driven development
- Testing legacy code
- The .gitignore file
- The activity diagram
- The actors of a system
- The domain model
- The environmental and social impact of a project
- The refactoring catalogue
- The refactoring process
- The scenarios of a use case
- The SOLID principles
- The state machine diagram
- The system sequence diagram
- The test pyramid
- The use case diagram
- Throwing, catching and propagating an exception
- Types of maintenance
- Usability tests
- User interface tests
- User stories and acceptance criteria
- xUnit assertions
Databases
70- ACID transactions
- Aggregate functions
- ALTER and DROP
- Backing up and restoring a database
- Boyce-Codd normal form
- Building a replicated cluster
- Cartesian product and division
- Connections and prepared statements
- Constraints in SQL
- CREATE TABLE and data types
- Cursors
- Data redundancy
- Database accounts: who gets in, and how
- Database federation
- Datalog: recursion and negation
- Denormalisation
- Document databases
- Entities, attributes, identifiers
- Exceptions inside the database
- First, second and third normal forms
- Forms and reports
- From the conceptual model to the relational model
- Functional dependencies
- Functions and CASE
- GRANT and REVOKE
- Graph databases
- GROUP BY and HAVING
- Indexes
- Inner joins
- INSERT, UPDATE, DELETE
- Integrity constraints
- Internationalising a database
- Isolation levels and anomalies
- Key-value stores
- Locks
- Mobile and embedded databases
- NULL in SQL
- Object-relational mapping (ORM)
- Optimising a query
- Outer joins
- Persisting objects
- Primary and foreign keys
- Procedural blocks
- Querying a graph with Cypher
- Querying Cassandra with CQL
- Querying MongoDB: find and aggregation
- Querying objects: OQL and object-relational SQL
- Relationships and cardinalities
- Sample and test data
- SELECT and WHERE
- Selection and projection
- Set operators in SQL
- Sorting, DISTINCT, LIMIT
- Stored procedures and functions
- Subqueries
- Tablespaces: where tables live
- The anomalies of a redundant table
- The CASE tool
- The conceptual data model
- The deductive database: facts and rules
- The execution plan
- The join in relational algebra
- The object database: identity and navigation
- The WITH clause
- Triggers
- Union, intersection, difference
- Users and roles
- Views
- Wide-column stores
- Window functions
Networking
59- Active Directory
- Advanced DHCP
- Advanced DNS
- Analysing a frame capture
- ARP
- Automating administration
- BGP
- Configuring a router
- DHCP and joining a network
- DNS
- E-mail: SMTP, IMAP, SPF, DKIM and DMARC
- Encapsulation
- Ethernet, MAC addresses and frames
- File shares: NFS and SMB
- FTP and SFTP
- HTTP
- HTTP/2, HTTP/3 and QUIC
- HTTPS and TLS
- ICMP
- Installing a network service
- IP addresses, ports and NAT
- IP and routing
- IPv4, masks and CIDR
- IPv6 on the network
- IPv6: addresses
- MQTT and connected devices
- Network devices
- Network diagnostic commands
- Network ports to know
- Network weaknesses
- OSPF
- Packet filtering
- Proxy and reverse proxy
- Quality of service
- Querying a service from the client side
- Real time: WebSocket, SSE and polling
- RIP
- Running mail: SMTP and IMAP
- Samba
- Service interoperability
- Setting up a host on the network
- Static routing
- Subnetting
- Switching
- TCP in depth: connection and reliability
- TCP in depth: windows and congestion
- TCP or UDP
- The CDN
- The client-server model
- The IP header
- The journey of a web request
- The LDAP directory
- The load balancer
- The OSI and TCP/IP models
- Transmission media
- UDP
- VLANs
- Web service architecture
- Wi-Fi
Algorithms
55- Abstract data types and encapsulation
- Analysing loops and recurrences
- Assertions and preconditions
- Balanced trees
- Best, worst and average case
- Big O notation
- Binary search
- Bubble sort
- Character strings
- Choosing a data structure
- Code audit tools
- Code metrics
- Code review for efficiency
- Complexity classes
- Conditions: if, else, else if
- Console input and output
- Counting operations
- Documentation
- Dynamic array and linked list
- Eco-design in code
- Functions, parameters and scope
- Heapsort
- Insertion sort
- Iterative versus recursive
- Lambdas and closures
- Linear search
- Loops: for and while
- Measuring execution time
- Merge sort
- Modularity
- Naming
- One-dimensional arrays
- Operators and precedence
- Optimising a program
- Orders of growth of algorithms
- Pass by value or by reference
- Profiling a program
- Queues
- Quicksort
- Reading and writing files
- Records
- Recursion
- Selection sort
- Sets as a data structure
- Stacks
- Static or dynamic collections
- Test data sets
- The binary search tree
- The hash table
- The heap and the priority queue
- Traversal and accumulation
- Two-dimensional arrays
- Variables, types and assignment
- What a flaw costs
- Working out a complexity
Operating systems
53- Accounts and groups
- Bash: functions and arrays
- Bash: quoting and expansions
- Configuration files
- Creating and removing users
- Critical section and mutex
- Deadlock
- Designing an application protocol
- Environment variables
- File commands
- File system calls
- File types, inodes and links
- Foreground and background
- fork, exec and wait
- How a file system is organised
- How a system boots
- Kernel, drivers and user space
- Locks and concurrent file access
- Making a script robust
- Owner, group and umask
- Package managers
- Page replacement
- Partitions and mounting
- Pipes
- Processes: states and PIDs
- Producer-consumer, readers-writers, dining philosophers
- Programming with signals
- Reading and filtering text
- Redirections and pipes
- Running tasks in parallel
- rwx permissions and chmod
- Scheduled tasks: cron and timers
- Scheduling algorithms
- Scripts: exit codes
- Scripts: loops
- Scripts: tests and conditions
- Scripts: variables and arguments
- sed and awk
- Semaphores and monitors
- Setting up a development machine
- Shared memory
- Shell wildcards
- Sockets
- sudo and root
- systemd services
- The concurrent server
- The Linux directory tree
- The operating system: role and families
- The steps of installing a system
- Threads
- Unix signals
- Virtual memory and paging
- Watching and controlling processes
Programming
39- 2D transformations
- 3D and rendering
- Abstract classes
- Activity diagram
- Algebra for imaging
- Analytic geometry for imaging
- API styles
- Association, aggregation, composition
- Attributes and methods
- Class diagram
- Colour science
- Comparing and sorting objects
- Constructors
- Encapsulation and visibility
- From diagram to code
- Garbage collector
- Generics
- HTTP status codes
- Inheritance
- Interfaces
- Inversion of control
- Iterators
- Lists, sets, dictionaries
- Particle systems
- Polymorphism, overriding, overloading
- Producing images
- References, equality, identity
- Sequence diagram
- Sound and video
- Stack and heap
- Static versus instance
- The client-side framework: rendering and reactivity
- The concurrent paradigm
- The digital image and its formats
- The distributed paradigm
- The embedded paradigm
- The functional paradigm
- The server-side framework
- Use case diagram
Data science and AI
36- Administering an analytics schema
- Analysis tools: pandas and scikit-learn
- Building a model into an application
- Choosing a chart
- Collecting big data and its file formats
- Data cleaning
- Database federation
- Decision trees and random forests
- Dimensionality reduction: principal component analysis
- Distributed mining: MapReduce and Spark
- Evaluating a model
- Exploring a massive dataset
- Extract, transform, load (ETL)
- Facts, measures and dimensions
- Frequent pattern mining
- Hierarchical and density-based clustering
- K-means clustering
- K-nearest neighbours
- Language models
- Migrating data and verifying the migration
- Neural networks
- Precomputing aggregates
- Reporting
- Scaling machine learning up
- Shaping data for learning
- Star and snowflake schemas
- Supervised learning: classifying and predicting
- Supervised, unsupervised and reinforcement learning
- The cube and OLAP operations
- The decision dashboard
- The families of AI: symbolic and learning
- The limits and biases of AI
- The mathematics of learning
- Training, evaluating, overfitting
- Transforming data for analysis
- Visualising big data
Cloud
26- Advanced Docker: hardening a container and keeping it alive
- Advanced Docker: lean images
- Cloning, backing up, restoring
- Container versus virtual machine
- Deployment models
- Docker Compose
- Docker: images and containers
- Hypervisors
- IaaS, PaaS, SaaS
- Kubernetes: configuration and storage
- Kubernetes: pods and Deployments
- Kubernetes: Services and Ingress
- Kubernetes: the architecture of a cluster
- Making a container's data persist
- Managing logs
- Monitoring cloud resources
- Networking a virtual machine
- Nomad
- Orchestration: autoscaling
- Orchestration: infrastructure described as code
- Partitioning and isolating: namespaces and cgroups
- The virtual machine: disks, images and snapshots
- Types of virtualisation
- Virtual networks
- Virtualised architectures
- Writing a Dockerfile
Computer architecture
22- Adder and multiplexer
- ASCII, Unicode and UTF-8
- Assembly and addressing modes
- Bases 2, 8 and 16
- Binary arithmetic and overflow
- Bits, bytes, kB and KiB
- From source to executable
- History of computing
- IEEE 754 floating point
- Integers and two's complement
- Interfaces and peripherals
- Interrupts
- Logic gates
- Memory allocation
- Microprocessor and microcontroller
- Parts of a PC
- Pointers
- Registers and instruction set
- The fetch-decode-execute cycle
- The memory hierarchy
- The stack and function calls
- Von Neumann architecture
Cryptography
19- AES
- Blockchain
- Certificates and public key infrastructure
- Computing in Z/nZ
- Cyclic groups and modular exponentiation
- DES
- Diffie-Hellman
- Digital signatures
- ElGamal
- Error-correcting codes
- Error-detecting codes: parity and CRC
- Frequency analysis
- Hash functions
- Modes of operation
- RSA
- The Caesar cipher
- The Hamming code
- The Hill cipher
- The Vigenère cipher
Security
19- Antivirus
- Authentication
- Backups
- Configuring a firewall
- EBIOS and Mehari
- Encrypting traffic
- Good practice
- How an attack unfolds
- Malware
- Risk analysis: the concepts
- Secure architectures
- Segmentation and filtering
- SSH: keys and tunnels
- System weaknesses
- The DMZ
- The firewall
- Types of attack
- VPNs: IPsec and WireGuard
- Web security
DevOps
14- Availability
- Centralising monitoring
- Containers in the pipeline
- Continuity and recovery plans
- Continuous delivery and deployment
- Continuous inspection
- Continuous integration and delivery
- Continuous integration: the server and its runners
- Deployment strategies
- Generic risks
- Mirroring and RAID levels
- Observability
- Scenario: a server, then a whole zone, goes down
- The stages of a pipeline
Theoretical computer science
10Computer science
9Data
6Learning paths
Decks put in the order you learn them, step by step, up to a badge.
- Writing your first programs
- Programming with objects
- Code that works and that others can pick up
- Building a web page
- Designing an interface people understand
- What happens inside the machine
- Commanding an operating system
- Making machines talk
- Modelling and querying a database
- Writing efficient code
- From a need to a specification
- Designing software that lasts
- Proving an application works
- Building a web application
- Going all the way on the web
- Building for the phone
- Programming close to the system
- Understanding how a network carries data
- Connecting an application to its database
- Shaping data well, in tables or otherwise
- Keeping a secret
- Running several machines inside one
- Making a machine read a language
- Growing a network
- Defending a system and a network
- Cryptography at work
- Data to decide with
- Predicting how fast a program runs
- Building on frameworks
- Programming images and sound
- Judging software quality
- Keeping software alive
- Storing without tables
- Orchestrating containers
- Shipping automatically
- Understanding what an AI does
- Automating a system with scripts
- Setting up an organisation's services
- Speeding up and spreading services
- Attacking to defend better
- Deploying to the cloud
- Staying up despite failure
- Presenting indicators on the web
- Running a database
- Feeding and exploring a data warehouse
- Handling big data
- Teaching a machine