{"as_of":"2026-08-14T11:01:00Z","caps":{"database_statements":6,"inbound":100,"outbound":100},"context_digest":"sha256:b8c1e446ec6deb0e6973c6460b525049dea9d66e401555cf5f67169e19362469","coverage":[{"denominator":38,"lane":"reference_resolution","note":"Typed states for the displayed outbound observations.","records_observed":38,"source":"paper_references, paper_reference_links","source_observed_at":"2026-08-12T18:49:55.198190Z","state":"measured"},{"denominator":38,"lane":"standing_notices","note":"One-hop event checks from named stored sources.","records_observed":38,"source":"scholarly_work_events, retraction_status_cache","source_observed_at":"2026-08-14T06:32:32.682623+00:00","state":"measured"},{"denominator":0,"lane":"inbound_itemization","note":"Pith citing papers itemized under the disclosed page cap.","records_observed":0,"source":"paper_references, paper_reference_links","source_observed_at":null,"state":"measured"},{"denominator":1,"lane":"external_citation_measurements","note":"A source-named dated measurement, never combined with another source.","records_observed":0,"source":"cited_works","source_observed_at":null,"state":"measured"}],"external_citation_measurements":[],"inbound":[],"links":{"evidence":"/evidence","html":"/paper/2411.11227/citation-record","integrity":"/paper/2411.11227/integrity","json":"/paper/2411.11227/citation-record.json","paper":"/paper/2411.11227"},"outbound":[{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.090007Z","title":null,"venue":null,"work_id":null,"year":2019},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":1,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.090007Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:1ade2fef73afaeb4332335989954e40f777a3bc1236740800e8ed4e30db12d17","observation_id":"2863ec10-1de1-4f5c-bc01-fbeddfea119c","resolution":{"observed_at":"2026-08-12T18:49:55.090007Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.069408Z","title":"Berliner","venue":null,"work_id":"66e82a00-a810-4559-99ac-5a8a0014b967","year":2002},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":2,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.093547Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:8f41f2cb9b8181441bb70525bf0410ba133454f3ac553ca9470b90e003d7c2c1","observation_id":"003748b6-3b87-4a9f-82d5-2c031de820f2","resolution":{"observed_at":"2026-08-12T18:49:56.072355Z","resolver_source":"raw_fallback","status":"malformed_identifier"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.096363Z","title":null,"venue":null,"work_id":null,"year":2006},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":3,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.096363Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:d11d9a616eff7aecb4589c5073440014f1679e3aac6290dc2801ea2f550db80b","observation_id":"ca5bb6df-711b-4694-9a73-392913532de3","resolution":{"observed_at":"2026-08-12T18:49:55.096363Z","resolver_source":null,"status":"malformed_identifier"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.1111/mbe.12177","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.318679Z","title":null,"venue":null,"work_id":"bb22dcb2-1856-4312-aa63-a6061dc37b02","year":2019},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":4,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.099284Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:496d8dc15f29f4dcbc75a4fa7f9692b80ce9de9e9f6c8cd579782349f840c6ff","observation_id":"662ebe57-4930-4495-9b5e-8e2c27507890","resolution":{"observed_at":"2026-08-12T18:49:55.321600Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.102289Z","title":"Becker, Michelle Craig, Greg Wilson, and Piotr Ba- naszkiewicz","venue":null,"work_id":null,"year":2019},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":5,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.102289Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:5f6cb4a54e8c5af4bfc140747e232e192bcf20b456359153056aa8a6724ba83e","observation_id":"115a1eef-fa49-40eb-bfa7-61993b32b169","resolution":{"observed_at":"2026-08-12T18:49:55.102289Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.056400Z","title":null,"venue":null,"work_id":"8840aaa8-ac45-4a81-b598-16c2a652c84c","year":2020},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":6,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.105215Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:905fdca36a83837236cd3bfc214657d66b2ad8a40bc0d7de8600be591bfe0b13","observation_id":"d9970dc6-b070-43ed-807a-c56346f6fbbd","resolution":{"observed_at":"2026-08-12T18:49:56.059208Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.108340Z","title":"Forlizzi, and Anind K","venue":null,"work_id":null,"year":2010},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":7,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.108340Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:7f0cab4fdac8a5fabfbe848baae05b4fc4ef45fff690763c6402760662142523","observation_id":"f6839aa7-c150-4cac-afd4-e44727354bbb","resolution":{"observed_at":"2026-08-12T18:49:55.108340Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.048467Z","title":null,"venue":null,"work_id":"b658a8a6-9f4d-4c22-b125-49d50557d51c","year":1991},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":8,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.111124Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:34ef22e4318fe45e32d0b16987745edc8ea01c51464801b3ffa8f0978e146e00","observation_id":"fc256869-e051-4805-b5af-9868082153ba","resolution":{"observed_at":"2026-08-12T18:49:56.051209Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.114018Z","title":null,"venue":null,"work_id":null,"year":2013},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":9,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.114018Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:a32dbe59b181c83f5f3c005ca0567a4f76680820cdf9252a2703553edf2730cd","observation_id":"2ae38f2f-85f3-4a86-8482-af67720cd0ed","resolution":{"observed_at":"2026-08-12T18:49:55.114018Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.1007/978-3-319-39690-3_14","metadata_source":"openalex","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-13T11:03:48.094449Z","title":null,"venue":"Smart innovation, systems and technologies","work_id":"129e38fa-77a0-44bd-9eb0-ebf5dd543b01","year":2016},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":10,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.116821Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:07fa370c5a69998e7eda91bcdf4aabea1b4052bae532b363a87049e4ef839237","observation_id":"2009945f-c184-46d9-aad3-f894f1bcd3b4","resolution":{"observed_at":"2026-08-12T18:49:55.307945Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.119614Z","title":null,"venue":null,"work_id":null,"year":2008},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":11,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.119614Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:eaf91d76106eee8adc6a0e001f288b3409fa913c029775dc2ac5341b8e474aae","observation_id":"26bf1344-f4ac-4ee6-8dd6-af3ca93fea0d","resolution":{"observed_at":"2026-08-12T18:49:55.119614Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.122456Z","title":null,"venue":null,"work_id":null,"year":2016},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":12,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.122456Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:b91c64ccba98e3c2904cd208a6ae231bfd72c2bda80387dfc30adaba0bf7120e","observation_id":"9622955d-6edb-4248-9225-3c97b8dd74fe","resolution":{"observed_at":"2026-08-12T18:49:55.122456Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":"8406.2011","doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.770572Z","title":null,"venue":null,"work_id":"820bcc28-493e-4714-9b00-c10c32d56de7","year":2012},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":13,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.125262Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:9c64232fefd218ca68827c597f25305b6bffd14ae129e4fce49b3d9e3b05156a","observation_id":"9ea220de-11f2-48a2-a3ec-b14c874c3bd1","resolution":{"observed_at":"2026-08-12T18:49:55.775094Z","resolver_source":"raw_fallback","status":"malformed_identifier"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.1007/s11251-012-9235-4","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.291597Z","title":null,"venue":null,"work_id":"11c9e1f3-9e15-4235-b18d-3d00acf6e2b2","year":2012},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":14,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.128368Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:73efbf52e13244831689aa46179031a0f2d8ecb726f8729c1c1284b19edde0c4","observation_id":"e3e9d511-3bf8-480c-8c77-22625c49bb38","resolution":{"observed_at":"2026-08-12T18:49:55.294504Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.1007/s10648-016-9379-x","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.282799Z","title":null,"venue":null,"work_id":"7675f472-161f-468e-badf-52f3577c8b25","year":2017},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":15,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.131380Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:289207b112a7f41d68fc2707d44510e967c958cbaecb1f44d02cf79ebb89adda","observation_id":"737874cd-b5bb-4c68-98f8-272e222fafe3","resolution":{"observed_at":"2026-08-12T18:49:55.286018Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":"6871.34697","doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.716726Z","title":null,"venue":null,"work_id":"16f81356-9d6d-4365-b8db-3b35447db381","year":2021},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":16,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.134628Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:597d92911cca5382ee3d73e0bec4f83e6b2dee35197070e9b85fe7d8e78546b5","observation_id":"757a9f90-d0ea-4d01-9832-16b70481278e","resolution":{"observed_at":"2026-08-12T18:49:55.721072Z","resolver_source":"raw_fallback","status":"malformed_identifier"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.138001Z","title":"Olney, and Sidney K","venue":null,"work_id":null,"year":2017},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":17,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.138001Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:caf16fbab649fc7d43597a08dfc1f2143d3cb4c6a8479aa0dddf8e08a64064d9","observation_id":"467d26d5-9d01-4115-a86d-da4ca2d0f02e","resolution":{"observed_at":"2026-08-12T18:49:55.138001Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.040096Z","title":null,"venue":null,"work_id":"2a9d03ee-a0c5-48fa-9820-6e5175ef69bb","year":2014},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":18,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.140786Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:c1b9c9fba9476d921a7aa5a5b144d5edd73658a3c7cba8722f4bccaeb139fd0d","observation_id":"337d64b3-d4b7-4aac-88da-084136a711f2","resolution":{"observed_at":"2026-08-12T18:49:56.042991Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.031346Z","title":null,"venue":null,"work_id":"f7142c36-8c17-4f4e-991b-bba384fae0c6","year":2001},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":19,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.143415Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:a9a230ba3793e1a113ff34e2e60f765684c8d993ddbb31843318ce1bbb4b387c","observation_id":"7732524d-c3b2-45cc-ae45-a5651966f729","resolution":{"observed_at":"2026-08-12T18:49:56.034420Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.1007/978-94-011-2968-8_3","metadata_source":"openalex","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-13T11:03:48.094449Z","title":"Resnick and Daniel P","venue":null,"work_id":"da3afd5d-f737-4e43-b391-50e60bc04422","year":1992},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":20,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.146804Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:c9a01be15a30058a9cf1c952b5825bd608bc1bb86a87fb5ab0828d4410214778","observation_id":"d8b1d103-f2cd-4b36-8e73-f58be508a74b","resolution":{"observed_at":"2026-08-12T18:49:55.276926Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.1145/3210577","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.265344Z","title":null,"venue":null,"work_id":"d4cd4ee6-5f85-4257-9a55-712c10deacd1","year":2019},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":21,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.149634Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:f4df38d2e6435c790679498d4f0188ae246f9ecee1170d157931e0aae0b3f1c3","observation_id":"84bc7241-0548-472c-9e46-a62fda007100","resolution":{"observed_at":"2026-08-12T18:49:55.268288Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.022437Z","title":null,"venue":null,"work_id":"4a5e93a1-7350-434d-9525-8ef820f5b596","year":2020},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":22,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.152497Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:244611d6be12c31cce6d2804ee1672b6f7d87cffded0a6a7d1e489e2a9551693","observation_id":"78009931-af16-4724-acea-bbd809279446","resolution":{"observed_at":"2026-08-12T18:49:56.025376Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.155131Z","title":"Savelson and Kasia Muldner","venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":23,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.155131Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:9e304842187cf871cbfd3fa888156e1600df3d08c097e265f9dab728d238862b","observation_id":"c7dca06d-0918-448d-bd5d-c0746f689e1b","resolution":{"observed_at":"2026-08-12T18:49:55.155131Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.013755Z","title":null,"venue":null,"work_id":"753c5340-3da7-487b-918a-83bcc5f91ef2","year":2018},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":24,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.157760Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:4280454916fc980a83f27a7b85529a3cdea4d09385e6e52754a14fc33a23dfc8","observation_id":"26cdfd44-c992-447c-a444-c45435c78203","resolution":{"observed_at":"2026-08-12T18:49:56.016765Z","resolver_source":"raw_fallback","status":"unresolved"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.160545Z","title":null,"venue":null,"work_id":null,"year":2017},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":25,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.160545Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:f712d7e7e16a2a708bd324e8a1154cab468d29d478a0e0bda5c41a3d6f2ea9fd","observation_id":"49118ec1-31a5-4e95-9b26-c934c958ff0d","resolution":{"observed_at":"2026-08-12T18:49:55.160545Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.3102/00346543211019105","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.256316Z","title":null,"venue":null,"work_id":"e11d3c68-26be-4163-b730-cc7685819f78","year":2021},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":26,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.163343Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:73851b834d1109774952e0c0f0f8317017ee05ccbea7ada9373616826d1ff263","observation_id":"4a67251e-ea5d-4d34-9cec-3eac0e95c92b","resolution":{"observed_at":"2026-08-12T18:49:55.259593Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.1016/j.ijcci.2019.04.002","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.246283Z","title":"Sridhar, Samantha W.T","venue":null,"work_id":"5cbca26a-858f-4014-adf9-0ee846eb57da","year":2019},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":27,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.166899Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:2151922ddd9cd9a0b34b0e367c22862dc8ac8dbf0456a2e114cad9d4602b53f9","observation_id":"21d740a9-6209-446f-b5d6-bc79c153476b","resolution":{"observed_at":"2026-08-12T18:49:55.249488Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[{"edge_observation":{"observed_at":"2026-08-13T00:18:27.341987+00:00","source":"paper_reference_links","state":"open"},"event_date":"2024-07-17","event_type":"correction","notice_doi":"10.1016/j.ijcci.2024.100673","provenance":{"observed_at":"2026-07-11T03:11:21.376655+00:00","source":"crossref","source_record_id":"10.1016/j.ijcci.2024.100673->10.1016/j.ijcci.2019.04.002:correction"}}],"reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.3390/educsci10070177","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.237308Z","title":null,"venue":null,"work_id":"9d341ce8-058a-47bc-aab1-f09291ce867d","year":2020},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":28,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.169917Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:2701e81076c68a7661f476642bacbc0745b2b9c1466a70e400fb7e2c273a70a7","observation_id":"b527ddb6-5069-4fd4-afd3-dee72d878869","resolution":{"observed_at":"2026-08-12T18:49:55.240574Z","resolver_source":"doi","status":"verified_exact"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.172961Z","title":null,"venue":null,"work_id":null,"year":2024},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":29,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.172961Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:93a18bc118351472f5787dd689b384649cf72317ee96415069cb76f9ba334307","observation_id":"a7a95202-b2b0-4062-be1d-18e569a72fd8","resolution":{"observed_at":"2026-08-12T18:49:55.172961Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.175659Z","title":null,"venue":null,"work_id":null,"year":2023},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":30,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.175659Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:388d03dcc57efa6dc075532dd6971a96d3e29cb31ac356bbfd1c8a383e5a059e","observation_id":"a9b9cea3-c6bd-498b-93c4-753b6d79ac1c","resolution":{"observed_at":"2026-08-12T18:49:55.175659Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.178524Z","title":null,"venue":null,"work_id":null,"year":2022},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":31,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.178524Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:87993df60ea5c10134521b228060abcbf15bba28f182b8b665906184f1ea9524","observation_id":"7822d860-833f-4812-8cce-21f79f36ca70","resolution":{"observed_at":"2026-08-12T18:49:55.178524Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:56.005234Z","title":null,"venue":null,"work_id":"dfc91425-ee38-4668-854c-e200697dc6f3","year":1994},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":32,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.181152Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:11cf657886c24ac8285d2b89c1db0be81672f68301677860ecec15f8b03d294f","observation_id":"8d934c80-b519-4908-a670-0fd0112fb125","resolution":{"observed_at":"2026-08-12T18:49:56.008172Z","resolver_source":"raw_fallback","status":"malformed_identifier"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.996691Z","title":null,"venue":null,"work_id":"b0a88f36-97e0-489a-9b39-52eff97643bd","year":2021},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":33,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.183766Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:af98c90c04bbc9adfef31939a3c454454faf46e60b2fbb218d5b6f5197fcae56","observation_id":"ba54cb99-2325-4978-a8de-9e2440912fb9","resolution":{"observed_at":"2026-08-12T18:49:55.999772Z","resolver_source":"raw_fallback","status":"malformed_identifier"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":"raw_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.988159Z","title":null,"venue":null,"work_id":"a9880602-162f-46e5-9d64-16fde451d30c","year":2009},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":34,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.186636Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:beabe87445e2b9fef88502a3600353395c9f5475feb2353bed539171a064fd8c","observation_id":"02be5df1-8765-48cd-9089-abaaaabc75dc","resolution":{"observed_at":"2026-08-12T18:49:55.991230Z","resolver_source":"raw_fallback","status":"malformed_identifier"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.189404Z","title":null,"venue":null,"work_id":null,"year":2022},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":35,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.189404Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:bb0746ec19ff4d57ffcf8ef2b4090a9196a3256deafc5d1e10b5416869d10b85","observation_id":"ae4a1a39-11d7-4d31-9a97-ccc5e1f4a8e6","resolution":{"observed_at":"2026-08-12T18:49:55.189404Z","resolver_source":null,"status":"malformed_identifier"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":{"arxiv_id":"1201.2021","last_updated":"2012-01-10T11:13:54Z","snapshot_observed_at":"2026-08-12T13:56:39.644614Z","submitted_at":"2012-01-10T11:13:54Z","title":"Stark Broadening and White Dwarfs","version":1},"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":"1201.2021","snapshot_observed_at":"2026-08-12T18:49:55.192250Z","title":null,"venue":null,"work_id":null,"year":2021},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":36,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.192250Z"},"links":{"cited_paper":"/paper/1201.2021","citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:5dc00dfe58830842c36796924c37bc5dafe503c7113dc37c0b71c6cdc08ce2ce","observation_id":"99e50219-9bc9-4ca8-a375-21aec1b50f80","resolution":{"observed_at":"2026-08-12T18:49:55.192250Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":"10.2190/et","metadata_source":"doi_reference","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.222787Z","title":null,"venue":null,"work_id":"c5bac186-df52-47dd-b699-1073ae7fc21a","year":2014},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":37,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.195431Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:ca3ed4f63827aeff4ff8a7d8622e1174e5a2ed597b46da13652f2af1b3b05690","observation_id":"719ffc7a-2038-43cf-ae49-2c61628d2160","resolution":{"observed_at":"2026-08-12T18:49:55.226544Z","resolver_source":"doi_truncated","status":"malformed_identifier"},"standing_notice":{"events":[],"observation":"No event found in the named queried sources as of 2026-08-14T06:32:32.682623+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"state":"measured"}},{"citation":{"cited_paper":null,"cited_work":{"arxiv_id":null,"doi":null,"metadata_source":null,"pith_arxiv_id":null,"snapshot_observed_at":"2026-08-12T18:49:55.198190Z","title":null,"venue":null,"work_id":null,"year":2019},"citing_paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming","version":1},"reference_index":38,"source":"pdf_text","source_observed_at":"2026-08-12T18:49:55.198190Z"},"links":{"citing_paper":"/paper/2411.11227"},"observation_digest":"sha256:7cc79980e29bdaf3fe39d0875dfc023e4731ccb47939e147795f320fa5a49975","observation_id":"ecd8c951-f0cd-4c19-881b-3c52fb3a0608","resolution":{"observed_at":"2026-08-12T18:49:55.198190Z","resolver_source":null,"status":"unresolved"},"standing_notice":{"events":[],"reason":"canonical_work_link_unavailable","source_receipts":[],"state":"unavailable"}}],"paper":{"arxiv_id":"2411.11227","last_updated":"2024-11-18T01:39:05Z","latest_version":1,"primary_category":"cs.CY","snapshot_observed_at":"2026-08-14T08:47:51.197746Z","submitted_at":"2024-11-18T01:39:05Z","title":"Investigating the Use of Productive Failure as a Design Paradigm for Learning Introductory Python Programming"},"reference_resolution":{"displayed":38,"state_counts":{"malformed_identifier":9,"metadata_mismatch":0,"parse_uncertain":0,"unresolved":20,"verified_exact":9,"verified_fuzzy":0},"total_outbound_references":38},"refusal":"A citation records a reference. It does not transfer a finding from one paper to another.","schema":"pith.paper-citation-record.v1","standing_sources":[{"observed_at":"2026-08-14T06:32:32.682623+00:00","source":"crossref"},{"observed_at":"2026-08-14T06:32:18.44784+00:00","source":"retraction_watch"}],"thesis":"As of 14 August 2026, this Paper Citation Record lists 38 of 38 outbound references and 0 inbound Pith citation observations for arXiv:2411.11227."}