Награды за "головы"

Статьи

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. Is CppCoreGuidelines C.21 correct?, https://stackoverflow.com/questions/38682675/is-cppcoreguidelines-c-21-correct
5. Lisp: Good News, Bad News, How to Win Big, https://www.dreamsongs.com/WIB.html
6. Objects Never? Well, Hardly Ever!, https://cacm.acm.org/magazines/2010/9/98017-objects-never-well-hardly-ever/fulltext
7. What Made Lisp Different, https://www.paulgraham.com/diff.html
8. Was Alan Kay wrong? And why does that matter?, https://braythwayt.com/2013/12/22/wrong.html
9. 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
10. Smalltalk: Getting the Message, https://web.archive.org/web/20250326043539/http://www.smalltalk.org/articles/article_20100320_a3_Getting_The_Message.html
11. A beginner's guide to C++ Ranges and Views, https://hannes.hauswedell.net/post/2019/11/30/range_intro/
12. Structured bindings in C++17, 5 years later, https://www.cppstories.com/2022/structured-bindings/
13. Use streams, pipes and redirects, https://learning.lpi.org/en/learning-materials/101-500/103/103.4/103.4_01/
14. Design By Contract, https://se.inf.ethz.ch/~meyer/publications/old/dbc_chapter.pdf
15. Gallery of Processor Cache Effects, https://igoro.com/archive/gallery-of-processor-cache-effects/
16. What Every Programmer Should Know About Memory, https://people.freebsd.org/%7Elstewart/articles/cpumemory.pdf
17. Concepts: The Future of Generic Programming, https://www.stroustrup.com/good_concepts.pdf
18. Implementation Inheritance Is Evil, https://medium.com/hackernoon/inheritance-based-on-internal-structure-is-evil-7474cc8e64dc
19. Uses and Abuses of Inheritance, Part 1, http://www.gotw.ca/publications/mill06.htm
20. Inheritance — What your mother never told you, https://isocpp.org/wiki/faq/strange-inheritance
21. Subtyping vs inheritance, https://www.cmi.ac.in/~madhavan/courses/pl2009/lecturenotes/lecture-notes/node28.html
22. Zero-overhead deterministic exceptions: Throwing values, https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0709r0.pdf
23. Is the Agile Manifesto still a thing?, https://www.atlassian.com/agile/manifesto
24. On the Role of Scientific Thought, https://www.cs.utexas.edu/users/EWD/ewd04xx/EWD447.PDF
25. Models of Software Acceptance, https://www.dreamsongs.com/Files/AcceptanceModels.pdf
26. C++20 Modules — Complete Guide, https://itnext.io/c-20-modules-complete-guide-ae741ddbae3d
27. 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/
28. The Illusion of Thinking, https://machinelearning.apple.com/research/illusion-of-thinking
29. Your Brain on ChatGPT, https://arxiv.org/abs/2506.08872
30. Can programming be liberated from the von Neumann Style?, http://worrydream.com/refs/Backus-CanProgrammingBeLiberated.pdf
31. Recursive Functions of Symbolic Expressions and Their Computation by Machine, https://www.cs.tufts.edu/~nr/cs257/archive/john-mccarthy/recursive.pdf
32. 21st Century C++, https://cacm.acm.org/blogcacm/21st-century-c/
33. SIMULA ACM Sessions, https://www.cs.tufts.edu/comp/150FP/archive/kristen-nygaard/hopl-simula.pdf
34. Smalltalk ACM Sessions, https://dl.acm.org/doi/pdf/10.1145/234286.1057828
35. Dr. Alan Kay on the Meaning of “Object-Oriented Programming”, https://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en
36. How I Declare My class And Why, https://howardhinnant.github.io/classdecl.html
37. Introducing the Rule of DesDeMovA, https://safecpp.com/2019/07/01/initial.html
38. C++ ACM Sessions, https://dl.acm.org/doi/pdf/10.1145/234286.1057836
39. Fundamental Concepts in Programming Languages, https://reed.cs.depaul.edu/jriely/447/assets/articles/strachey-fundamental-concepts-in-programming-languages.pdf
40. On Understanding Types, Data Abstraction, and Polymorphism, http://lucacardelli.name/Papers/OnUnderstanding.A4.pdf
41. Кратко про библиотеку Range в C++, https://habr.com/ru/companies/otus/articles/841456/
42. Beyond errno Error Handling, https://insights.sei.cmu.edu/documents/4054/2016_017_101_484207.pdf
43. Boost.Contract, https://www.boost.org/doc/libs/1_82_0/libs/contract/doc/html/index.html
44. What is type erasure?, https://quuxplusone.github.io/blog/2019/03/18/what-is-type-erasure/
45. Solid relevance, https://blog.cleancoder.com/uncle-bob/2020/10/18/Solid-Relevance.html
46. Design Principles and Design Patterns, http://www.objectmentor.com/resources/articles/Principles_and_Patterns.pdf
47. Data Abstraction and Hierarchy, https://www.cs.tufts.edu/~nr/cs257/archive/barbara-liskov/data-abstraction-and-hierarchy.pdf
48. Single Responsibility Principle, https://blog.cleancoder.com/uncle-bob/2014/05/08/SingleReponsibilityPrinciple.html
49. Principles for Computer System Design, https://bwlampson.site/Slides/TuringLecture.htm
50. John Carmack on Inlined Code, http://number-none.com/blow/john_carmack_on_inlined_code.html
51. How do commitees invent?, http://www.melconway.com/Home/Committees_Paper.html
52. In-depth: static code analysis, https://www.gamedeveloper.com/programming/in-depth-static-code-analysis
53. Why I don't spend time with modern C++ anymore, https://hackerbits.com/wp-content/uploads/2016/11/hacker_bits_issue11.pdf
54. One year of C, https://floooh.github.io/2018/06/02/one-year-of-c.html
55. Type erasure, https://www.artima.com/articles/on-the-tension-between-object-oriented-and-generic-programming-in-c
56. A Stream IO System, https://cseweb.ucsd.edu/classes/fa01/cse221/papers/ritchie-stream-io-belllabs84.pdf
57. A Literate Program, https://dl.acm.org/doi/pdf/10.1145/5948.315654
58. The UNIX Time-Sharing System, https://dsf.berkeley.edu/cs262/unix.pdf
59. Deferred execution and lazy evaluation, https://learn.microsoft.com/en-us/dotnet/standard/linq/deferred-execution-lazy-evaluation
60. The mechanical evaluation of expressions, https://www.cs.cmu.edu/~crary/819-f09/Landin64.pdf
61. A Curious Course on Coroutines and Concurrency, https://www.dabeaz.com/coroutines/Coroutines.pdf
62. A beginner's guide to C++ ranges and views, https://hannes.hauswedell.net/post/2019/11/30/range_intro/
63. Кратко про библиотеку ranges в С++, https://habr.com/ru/companies/otus/articles/841456/
64. The Incremental Garbage Collection of Processes, http://home.pipeline.com/~hbaker1/Futures.html
65. Futures and Promises, http://dist-prog-book.com/chapter/2/futures.html
66. Incremental Consistency Guarantees for Replicated Objects, https://www.usenix.org/system/files/conference/osdi16/osdi16-guerraoui.pdf
67. Operation Costs in CPU Clock Cycles, http://ithare.com/infographics-operation-costs-in-cpu-clock-cycles/
68. Gallery of Processor Cache Effects, https://igoro.com/archive/gallery-of-processor-cache-effects/
69. Cache: a place for concealment and safekeeping, https://manybutfinite.com/post/intel-cpu-caches/
70. Bit Twiddling Hacks, https://graphics.stanford.edu/~seander/bithacks.html
71. Handles are the better pointers, https://floooh.github.io/2018/06/17/handles-vs-pointers.html
72. Fundamentals of generic programming, https://stepanovpapers.com/DeSt98.pdf
73. Generic programming, https://www.stepanovpapers.com/genprog.pdf
74. Higher order functions considered unnecessary for higher order programming, https://cseweb.ucsd.edu/~goguen/pps/utyop.pdf
75. Rational approach to consciousness, https://academic.oup.com/nc/article/2021/2/niab034/6397521
76. Functional error handling with OPTIONAL and EXPECTED, https://accu.org/journals/overload/26/143/brand_2462/

Лекции

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

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

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

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

Опросы

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