{"as_of":"2026-08-22T21:45:00Z","caps":{"database_statements":6,"inbound":100,"outbound":100},"context_digest":"sha256:66dd1b522caafd7c8c3106582f17804c32a38fbf73866a914936953e20c2a87d","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-22T06:32:14.747728+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-16T23:14:42.621996Z","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:44cfba4f125696cf1dd534f1c69d57a1dc50a17c1bd73647d5d327e1c7c11ee8","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-16T23:14:42.621996Z","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:45c4a4d7d0b05da6e3a4bcf2eb20ea2fb000ef125df3f2d2cc438928690eb26b","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:08adf400c74a195ac04de0b1bc8f24f269f90db089a1472a2a2fb4c4dbe76d09","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-16T23:14:42.621996Z","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:b8b01b6a03749e9dcb93d1e4aacab245b17469faa1f6da1c3eb619668c7e13ee","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:fb0be66be7561c013686546a259e0dc108cf6782c1b04f857acf5f1090752021","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-16T23:14:42.621996Z","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:5df7bac7c3ea68b7c104f6d1a5440747caa2f809693b267cae3b1eabba4bee6c","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:c17c6e1232119f3400b39062898c57141b208032829839b0c6713bfab88055c4","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-16T23:14:42.621996Z","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:731784accd603bcc66f88f3a83a3a0e0e42a0a627e7cd05c5f5289e0deb1553b","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:17b4dd1aa889a95d20cb153ef0f9de5889194251e51c26dbddd4d33247fe7338","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-16T23:14:42.621996Z","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:981adf11c80d1f1a195ed5be7214d9dd4417f9c38ef8fe34be7cb23140b6f0c2","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:3f0d46eb8d073206a9fa5ebf23afd31acdf70eb004faf43902349436b8c8a00c","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-16T23:14:42.621996Z","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:8f76f4b91ed832e54f209ff1d7d9316f94a115b92dce2c4670942eaa891e1150","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-16T23:14:42.621996Z","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:7e6c1558e691fea4c89796883c95939bc7733c9292b2e019d5643d1d55e44995","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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":"openalex","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-20T11:03:42.707129Z","title":null,"venue":"Instructional Science","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-16T23:14:42.621996Z","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:83227f9995a2ee149d701bff071751f5ed9728e9fc6464fe038201f496ed0608","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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":"openalex","pith_arxiv_id":null,"snapshot_observed_at":"2026-08-19T11:03:45.297681Z","title":null,"venue":"Educational Psychology Review","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-16T23:14:42.621996Z","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:b58cfe9e071ed62f5b436471982e0c27830b3ad14274a6eb6ace13794c7ff0ea","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:9bfbecf3d0be1c18f48c956d4ef01f6c81df3133e0e69105af0be9284dd3611f","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:a341eab0e3d79ede4898c8362ae0f4dbe6f69983501b8c3f885abd93842ad941","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-16T23:14:42.621996Z","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:188cf9d19aebc822d353ceb6df304abd493cb1495391e5c5d46b25533d69b8f4","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:761eb3e57d64aa0586310bf0f473562d943c66ee0205240a439df71d538d2702","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:e54d1d2c103ee77b49815d5c7d792cf471d062c797ee3aa5ee74a52a8f6d6b96","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:0fe0f67573b173ad77f0fb2c9f4d042a4292ec52d064cbc54a5809de43cfcd96","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:b1755a717c24d8ec53bd8e35765fa82de67503aa52d77cbfdd03290959bf9655","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:bb6ea30c94e637a7908852196eb173d8725665169c5f620762a5748f77a99a3d","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-16T23:14:42.621996Z","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:6b31706982676ef64e5e8fc35ecdc1db05231357dd9d30838fa0205710694e88","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:3a728ffee98e3fc996a47e3fb90c317071301d6e00a4fd8f727ac017aa5ba114","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-16T23:14:42.621996Z","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:0c08953add425711da611405fbcdb5c0983f0f9e487861690d579f5769bc873c","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:a2c89a2208a43069396a64e57d9719d454c369956e53ac3c8121d43cf43e142f","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-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:de783faf563e8ad5c1c499e16c9024ff9578f09fe19efb89bbb526b39942d41c","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:dd3b5d3208f939861d24ed4bbb6179faf7440bb8d6c324573885c04f1fdd4633","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-16T23:14:42.621996Z","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:4b5e45f1b4b53e4eed45920337e8966306a482539a431be0a7a1852a0c0ff0b1","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-16T23:14:42.621996Z","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:331fcd403d7de8476708cb5368fa257f93960874930748343539df5189e1a69f","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-16T23:14:42.621996Z","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:053f3834aa2d64832f0b3a2ac03c90210027c672b01894674b44af44ba1b5e0c","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:1169fc881905fee6390c99d9ccc198cfa2d516f94902e1c401dd89e0cf502019","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:6ec24a330e988eb711bb3b11f114eb16a665272707a4634b86f61761e3c2178e","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:f87bc9773991d1a6c20ea0f20bfe85e1a1fd4215456aa83ee4f816582a18b621","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-15T13:20:36.452060Z","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-16T23:14:42.621996Z","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:c2822e4c1bdf14cf617426719db80cca19603dcd5343754d0a58951123fbf00b","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-16T23:14:42.621996Z","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:ef2a48e7ee92f0a289a364d639d3d84a5be5fac0e1c8939eece11bb8ff6cf9a6","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-22T06:32:14.747728+00:00.","reason":null,"source_receipts":[{"observed_at":"2026-08-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+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-16T23:14:42.621996Z","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:3082a88cfbfd4ea72abbf17b12e0b35e07efe8c1dea4db40a14752a9358f80b3","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-16T23:14:42.621996Z","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-22T06:32:14.747728+00:00","source":"crossref"},{"observed_at":"2026-08-22T06:32:06.552537+00:00","source":"retraction_watch"}],"thesis":"As of 22 August 2026, this Paper Citation Record lists 38 of 38 outbound references and 0 inbound Pith citation observations for arXiv:2411.11227."}