Источники информации

Статьи

Образование

1. Laptop multitasking hinders classroom learning for both users and nearby peers, https://www.sciencedirect.com/science/article/pii/S0360131512002254
2. The Pen Is Mightier Than the Keyboard: Advantages of Longhand Over Laptop Note Taking, https://journals.sagepub.com/doi/abs/10.1177/0956797614524581
3. Improved Learning in a Large-Enrollment Physics Class, https://www.science.org/doi/10.1126/science.1201783
4. On the Role of Scientific Thought, https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD447.PDF
5. Rational approach to consciousness, https://academic.oup.com/nc/article/2021/2/niab034/6397521

Эффекты LLM

1. Thinking—Fast, Slow, and Artificial, https://papers.ssrn.com/sol3/papers.cfm?abstract_id=6097646
2. How AI Impacts Skill Formation, https://arxiv.org/pdf/2601.20245
3. The Impact of Generative AI on Critical Thinking, https://www.microsoft.com/en-us/research/publication/the-impact-of-generative-ai-on-critical-thinking-self-reported-reductions-in-cognitive-effort-and-confidence-effects-from-a-survey-of-knowledge-workers/
4. The Illusion of Thinking, https://machinelearning.apple.com/research/illusion-of-thinking
5. Your Brain on ChatGPT, https://arxiv.org/abs/2506.08872
6. Permission structures, https://substack.com/@mattdinan/p-173089195

Объекты

1. Objects Never? Well, Hardly Ever!, https://cacm.acm.org/magazines/2010/9/98017-objects-never-well-hardly-ever/fulltext
2. Was Alan Kay wrong? And why does that matter?, https://braythwayt.com/2013/12/22/wrong.html
3. Smalltalk: Getting the Message, https://web.archive.org/web/20250326043539/http://www.smalltalk.org/articles/article_20100320_a3_Getting_The_Message.html
4. Dr. Alan Kay on the Meaning of “Object-Oriented Programming”, https://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en
5. Design principles behind Smalltalk, https://www.cs.virginia.edu/~evans/cs655/readings/smalltalk.html

Фундаментальные аспекты программирования

1. Can programming be liberated from the von Neumann Style?, http://worrydream.com/refs/Backus-CanProgrammingBeLiberated.pdf
2. SIMULA ACM Sessions, https://www.cs.tufts.edu/comp/150FP/archive/kristen-nygaard/hopl-simula.pdf
3. Smalltalk ACM Sessions, https://dl.acm.org/doi/pdf/10.1145/234286.1057828
4. Fundamental Concepts in Programming Languages, https://reed.cs.depaul.edu/jriely/447/assets/articles/strachey-fundamental-concepts-in-programming-languages.pdf
5. On Understanding Types, Data Abstraction, and Polymorphism, http://lucacardelli.name/Papers/OnUnderstanding.A4.pdf
6. Principles for Computer System Design, https://bwlampson.site/Slides/TuringLecture.htm
7. How do commitees invent?, http://www.melconway.com/Home/Committees_Paper.html
8. John Carmack on Inlined Code, http://number-none.com/blow/john_carmack_on_inlined_code.html
9. Think in Math, Write in Code, https://www.jmeiners.com/think-in-math/
10. Fundamentals of generic programming, https://stepanovpapers.com/DeSt98.pdf
11. Generic programming, https://www.stepanovpapers.com/genprog.pdf
12. What is type erasure?, https://quuxplusone.github.io/blog/2019/03/18/what-is-type-erasure/
13. Type erasure, https://www.artima.com/articles/on-the-tension-between-object-oriented-and-generic-programming-in-c
14. Configuration flags are where software goes to rot, https://00f.net/2026/04/11/config-flags/

Функциональное программирование

1. Lisp: Good News, Bad News, How to Win Big, https://www.dreamsongs.com/WIB.html
2. What Made Lisp Different, https://www.paulgraham.com/diff.html
3. Recursive Functions of Symbolic Expressions and Their Computation by Machine, https://www.cs.tufts.edu/~nr/cs257/archive/john-mccarthy/recursive.pdf
4. The mechanical evaluation of expressions, https://www.cs.cmu.edu/~crary/819-f09/Landin64.pdf
5. The Discoveries of Continuations, https://homepages.inf.ed.ac.uk/wadler/papers/papers-we-love/reynolds-discoveries.pdf
6. Higher order functions considered unnecessary for higher order programming, https://cseweb.ucsd.edu/~goguen/pps/utyop.pdf

Потоки ввода/вывода

1. A Literate Program, https://dl.acm.org/doi/pdf/10.1145/5948.315654
2. Deferred execution and lazy evaluation, https://learn.microsoft.com/en-us/dotnet/standard/linq/deferred-execution-lazy-evaluation
3. Use streams, pipes and redirects, https://learning.lpi.org/en/learning-materials/101-500/103/103.4/103.4_01/
4. A Stream IO System, https://cseweb.ucsd.edu/classes/fa01/cse221/papers/ritchie-stream-io-belllabs84.pdf
5. The UNIX Time-Sharing System, https://dsf.berkeley.edu/cs262/unix.pdf
6. A Curious Course on Coroutines and Concurrency, https://www.dabeaz.com/coroutines/Coroutines.pdf
7. The Incremental Garbage Collection of Processes, http://home.pipeline.com/~hbaker1/Futures.html
8. Futures and Promises, http://dist-prog-book.com/chapter/2/futures.html
9. Incremental Consistency Guarantees for Replicated Objects, https://www.usenix.org/system/files/conference/osdi16/osdi16-guerraoui.pdf

C++

1. 21st Century C++, https://cacm.acm.org/blogcacm/21st-century-c/
2. C++ ACM Sessions, https://dl.acm.org/doi/pdf/10.1145/234286.1057836
3. Is CppCoreGuidelines C.21 correct?, https://stackoverflow.com/questions/38682675/is-cppcoreguidelines-c-21-correct
4. A beginner's guide to C++ Ranges and Views, https://hannes.hauswedell.net/post/2019/11/30/range_intro/
5. Structured bindings in C++17, 5 years later, https://www.cppstories.com/2022/structured-bindings/
6. Concepts: The Future of Generic Programming, https://www.stroustrup.com/good_concepts.pdf
7. Zero-overhead deterministic exceptions: Throwing values, https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0709r0.pdf
8. C++20 Modules — Complete Guide, https://itnext.io/c-20-modules-complete-guide-ae741ddbae3d
9. Introducing the Rule of DesDeMovA, https://safecpp.com/2019/07/01/initial.html
10. Кратко про библиотеку Range в C++, https://habr.com/ru/companies/otus/articles/841456/
11. Why I don't spend time with modern C++ anymore, https://hackerbits.com/wp-content/uploads/2016/11/hacker_bits_issue11.pdf
12. A beginner's guide to C++ ranges and views, https://hannes.hauswedell.net/post/2019/11/30/range_intro/
13. One year of C, https://floooh.github.io/2018/06/02/one-year-of-c.html
14. C Is Not a Low-level Language, https://queue.acm.org/detail.cfm?id=3212479
15. How I Declare My class And Why, https://howardhinnant.github.io/classdecl.html

Обработка ошибок

1. Beyond errno Error Handling, https://insights.sei.cmu.edu/documents/4054/2016_017_101_484207.pdf
2. Boost.Contract, https://www.boost.org/doc/libs/1_82_0/libs/contract/doc/html/index.html
3. Functional error handling with OPTIONAL and EXPECTED, https://accu.org/journals/overload/26/143/brand_2462/

Производительность

1. Gallery of Processor Cache Effects, https://igoro.com/archive/gallery-of-processor-cache-effects/
2. What Every Programmer Should Know About Memory, https://people.freebsd.org/%7Elstewart/articles/cpumemory.pdf
3. In-depth: static code analysis, https://www.gamedeveloper.com/programming/in-depth-static-code-analysis
4. Operation Costs in CPU Clock Cycles, http://ithare.com/infographics-operation-costs-in-cpu-clock-cycles/
5. Cache: a place for concealment and safekeeping, https://manybutfinite.com/post/intel-cpu-caches/
6. Handles are the better pointers, https://floooh.github.io/2018/06/17/handles-vs-pointers.html
7. Bit Twiddling Hacks, https://graphics.stanford.edu/~seander/bithacks.html

Дизайн ПО

1. Domain Specific Languages - Ruby, a Sign Post on the Road to Smalltalk, http://onsmalltalk.com/domain-specific-languages-ruby-a-sign-post-on-the-road-to-smalltalk
2. Design By Contract, https://se.inf.ethz.ch/~meyer/publications/old/dbc_chapter.pdf
3. Is the Agile Manifesto still a thing?, https://www.atlassian.com/agile/manifesto
4. Models of Software Acceptance, https://www.dreamsongs.com/Files/AcceptanceModels.pdf
5. Design Principles and Design Patterns, http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf
6. Single Responsibility Principle, https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html
7. Solid relevance, https://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Relevance.html
8. Codin' Dirty, https://htmx.org/essays/codin-dirty/

Наследование

1. Data Abstraction and Hierarchy, https://www.cs.tufts.edu/~nr/cs257/archive/barbara-liskov/data-abstraction-and-hierarchy.pdf
2. Subtyping, Subclassing, and Trouble with OOP, https://okmij.org/ftp/Computation/Subtyping/
3. Subclassing errors, OOP style and practically checkable rules to prevent them, https://okmij.org/ftp/Computation/Subtyping/Preventing-Trouble.html
4. Implementation Inheritance Is Evil, https://medium.com/hackernoon/inheritance-based-on-internal-structure-is-evil-7474cc8e64dc
5. Uses and Abuses of Inheritance, Part 1, http://www.gotw.ca/publications/mill06.htm
6. Inheritance — What your mother never told you, https://isocpp.org/wiki/faq/strange-inheritance
7. Subtyping vs inheritance, https://www.cmi.ac.in/~madhavan/courses/pl2009/lecturenotes/lecture-notes/node28.html

Лекции

1. Move semantics, https://www.youtube.com/watch?v=vLinb2fgkHk
2. Hot Code Reloading in C, https://youtu.be/Y57ruDOwH1g
3. Zero-Cost Abstractions in C++, https://www.youtube.com/watch?v=DLgM570cujU
4. Zero Cost Abstractions in C++20, Rust, & Zig, https://www.youtube.com/watch?v=43X9ia-qpds
5. Systematic Error Handling in C++, https://www.youtube.com/watch?v=kaI4R0Ng4E8
6. Jon Blow's Design decisions on creating Jai, https://www.youtube.com/watch?v=uZgbKrDEzAs
7. Наибольшая общая мера последние 2500 лет, https://www.youtube.com/watch?v=zwucsB2EfXc
8. Measuring the impact of AI on software engineering, https://youtu.be/xHHlhoRC8W4?si=x4KPHBk1cPJk3fhL&t=1519
9. Vibe Coding - Is this really the best we can do? The future of programming, https://www.youtube.com/watch?v=EPtU4JNATtM
10. Why the Real Computer Revolution Never Happened, https://youtu.be/MbEZ-DC0L-g
11. Fundamentals of Lambda-calculus and Functional Programming, https://www.youtube.com/watch?v=3VQ382QG-y4
12. JavaScript на службе у теоретической информатики, https://www.youtube.com/watch?v=T66wMYbtfNA
13. C++ Reflection, https://www.youtube.com/watch?v=H3IdVM4xoCU
14. Joe Armstrong interviews Alan Kay, https://www.youtube.com/watch?v=fhOHn9TClXY
15. Back to Basics: RAII and the Rule of Zero, https://www.youtube.com/watch?v=7Qgd9B1KuMQ
16. The Essence of C++, https://www.youtube.com/watch?v=ZXc_z1sNbfA
17. There are no zero-cost abstractions, https://www.youtube.com/watch?v=rHIkrotSwcc
18. When C++ Zero-Cost Abstraction Fails, https://www.youtube.com/watch?v=EPI7dW5CUfc
19. Inheritance is the base class of evil, https://www.youtube.com/watch?v=bIhUE5uUFOA
20. The Last Programming Language, https://youtu.be/P2yr-3F6PQo
21. We Really Don't Know How to Compute!, https://www.youtube.com/watch?v=HB5TrK7A4pI
22. Rethink Polymorphism in C++, https://www.youtube.com/watch?v=zI0DOKN6zr0
23. Concept-based Generic Programming, https://www.youtube.com/watch?v=1p6So6vE5WM
24. C++ Metaprogramming sucks!, https://www.youtube.com/watch?v=xfkwepKNjmI
25. Cost of abstractions in embedded systems, https://www.youtube.com/watch?v=m2uGMI3c91c
26. 105 STL Algorithms in Less Than an Hour, https://youtu.be/2olsGf6JIkUt=554
27. Alex Stepanov, Generic Programming, and the STL, https://youtu.be/yUa6Uxq25tQ
28. Contracts for C++, https://www.youtube.com/watch?v=Lu-sa6cRaz4
29. The mess we’re in, https://www.youtube.com/watch?v=lKXe3HUG2l4
30. Object-oriented program: best practices, https://youtu.be/c0lutJECNUA
31. The big OOPs, https://youtu.be/wo84LFzx5nI
32. Embrace no-paradigm programming!, https://www.youtube.com/watch?v=fwXaRH5ffJM
33. C++ Type Erasure Demystified, https://www.youtube.com/watch?v=p-qaf6OS_f4
34. How to get the benefits of Rust traits for dynamic polymorphism in C++, https://www.youtube.com/watch?v=uM72qP5Wh18
35. Where does bad code come from, https://youtu.be/7YpFGkG-u1w
36. Breaking Dependencies: SOLID, https://youtu.be/Ntraj80qN2k
37. The Past, Present and Future of Programming Languages, https://www.youtube.com/watch?v=8-3QwoAmyuk
38. Functional Data Structures in C++, https://www.youtube.com/watch?v=OsB09djvfl4
39. Functional Design Patterns, https://www.youtube.com/watch?v=srQt1NAHYC0
40. A Crash Course in Category Theory, https://youtu.be/JH_Ou17_zyU
41. Understanding, Using and Improving std::generator, https://www.youtube.com/watch?v=l9qKGGgnZYg
42. std::allocator is to Allocation what std::vector is to Vexation, https://youtu.be/LIb3L4vKZ7U
43. Writing cache friendly C++, https://youtu.be/Nz9SiF0QVKY
44. Psychological Warfare in Reverse Engineering, https://youtu.be/HlUe0TUHOIc
45. Want fast C++? Know your hardware!, https://youtu.be/BP6NxVxDQIs
46. Modern C and What We Can Learn From It, https://youtu.be/QpAhX-gsHMs
47. Generic programming considered harmful, https://www.youtube.com/watch?v=jXQ6WtYmfZw
48. Thinking Above the Code, https://www.youtube.com/watch?v=-4Yp3j_jk8Q
49. Thinking outside the box of code, https://www.youtube.com/watch?v=CoW6Rk7Nx2M
50. Pipeline-oriented programming, https://www.youtube.com/watch?v=ipceTuJlw-M
51. Understanding, Using and Improving std::generator, https://www.youtube.com/watch?v=l9qKGGgnZYg
52. I made Coroutines from scratch, https://www.youtube.com/watch?v=sYSP_elDdZw
53. Async vs Multithreading, https://www.youtube.com/watch?v=IGv5WYYmyfo
54. Data-Oriented Design and C++, https://www.youtube.com/watch?v=rX0ItVEVjHc
55. CPU design effects, https://youtu.be/ICKIMHCw--Y
56. Writing cache friendly C++, https://www.youtube.com/watch?v=Nz9SiF0QVKY
57. Practical Data Oriented Design, https://youtu.be/IroPQ150F6c
58. Intro to Data-Oriented Design for Games, https://www.youtube.com/watch?v=WwkuAqObplU
59. Data oriented design in practice, https://www.youtube.com/watch?v=NWMx1Q66c14
60. Monads are everywhere, https://www.youtube.com/watch?v=nGhoZzihbHY
61. Monads in modern C++, https://www.youtube.com/watch?v=cE_YaFMhTK8
62. Монады в C#; элементы теории категорий, https://www.youtube.com/watch?v=hPTOe8KRw_A
63. What is IO monad?, https://youtu.be/fCoQb-zqYDI
64. Relative pointers, https://www.youtube.com/watch?v=Z0tsNFZLxSU
65. From Here To Lambda And Back Again, https://www.youtube.com/watch?v=vMDHpPN_p08
66. Jonathan Blow on Programming Language Design, https://www.youtube.com/watch?v=e6crOMC9WCE
67. Jai Demo and Design Explanation, https://www.youtube.com/watch?v=IdpD5QIVOKQ
68. Rust and the price of ignoring theory, https://www.youtube.com/watch?v=1iPWt1gvT_w
69. Four Languages from Forty Years Ago, https://www.youtube.com/watch?v=mRwHZTNGdoY
70. Rob Pike on software engineering, https://www.youtube.com/watch?v=SlasmhEcXDo
71. The Only Unbreakable Law, https://www.youtube.com/watch?v=5IUj1EZwpJY

Shorts

1. Intro to Lambda Calculus: Syntax, evaluation, terminology, https://www.youtube.com/watch?v=b5VhYkvOk30
2. Lambda Calculus - Computerphile, https://www.youtube.com/watch?v=eis11j_iGMs
3. Terry Davis McDonald’s Interview, https://www.youtube.com/shorts/1MSy6epsU6Y
4. Conway's Game of Life in APL, https://www.youtube.com/watch?v=a9xAKttWgP4
5. struct or class - new or delete, https://youtu.be/zjkuXtiG1og
6. Casey Muratori on OOP, https://www.youtube.com/watch?v=0WYgKc00J8s
7. Jon Blow on OOP, https://www.youtube.com/watch?v=04ksL1hf_p8
8. Casey Muratori on Zero-Cost Abstractions, https://www.youtube.com/watch?v=B2BFbs0DJzw
9. The Amazing Power of C++26's Template For Statements, https://www.youtube.com/watch?v=yaWiGLSDc64
10. Panic vs Error, https://www.youtube.com/watch?v=TQOLosBgX20
11. Casey Muratori on getting rid of the OOP mindset, https://www.youtube.com/watch?v=GKYCA3UsmrU
12. Don't Model the Problem, https://www.youtube.com/watch?v=WcAWZGyB32U
13. Stop telling me about _Generic, https://www.youtube.com/watch?v=oEL9x6pP4FM
14. The Truth About Software Development, https://www.youtube.com/watch?v=mbEzhI3cmmo
15. My thoughts on Y Combinator, https://www.youtube.com/watch?v=L7x2ufU1c9Y
16. Why Go Or Rust On New Projects, https://www.youtube.com/watch?v=p-tb1ZfkwgQ

Документация

1. libstdc++ Source Documentation, https://gcc.gnu.org/onlinedocs/gcc-4.6.2/libstdc++/api/index.html
2. C++ C++26 standard RFC list, https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/
3. GNU Coreutils Manual, https://www.gnu.org/software/coreutils/manual/html_node/Concept-index.html
4. Google C++ Style Guide, https://google.github.io/styleguide/cppguide.html
5. Programming in C++, Rules and Recommendations, https://www.doc.ic.ac.uk/lab/cplus/c++.rules/
6. LLVM Coding Standards, https://llvm.org/docs/CodingStandards.html
7. C++ Library Design Guidelines, https://github.com/cplusplus/LEWG/blob/archive/library-design-guidelines.md

Книги

1. Object thinking, https://archive.org/details/objectthinking0000west/page/n7/mode/2up
2. Concepts in Programming Languages, https://homepages.dcc.ufmg.br/~camarao/lp/concepts.pdf
3. Programming in SML, https://www.cs.cmu.edu/~rwh/isml/book.pdf
4. Object-Oriented Software Construction, https://bertrandmeyer.com/wp-content/upLoads/OOSC2.pdf
5. Data-Oriented Design, https://www.dataorienteddesign.com/dodmain/
6. A Programming Language, https://www.softwarepreservation.org/projects/apl/Books/APROGRAMMING%20LANGUAGE
7. Sketchpad, https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-574.pdf
8. Object-Oriented Design with Smalltalk, https://scg.unibe.ch/archive/lectures/DucasseLectures/Duca00y1SmalltalkLectures.pdf
9. The Art and Science of Smalltalk, https://rmod-files.lille.inria.fr/FreeBooks/Art/artAdded174186187Final.pdf
10. Object-Oriented Programming Using C++, https://icarus.cs.weber.edu/~dab/cs1410/textbook/
11. Category theory for scientists, https://arxiv.org/pdf/1302.6946
12. Data structures in practice, https://github.com/djiangtw/data-structures-in-practice-public
13. Modern C, https://gustedt.gitlabpages.inria.fr/modern-c/

Опросы

1. The 2025 Developer Survey, https://survey.stackoverflow.co/2025
2. TIOBE Index, https://www.tiobe.com/tiobe-index/