https://www.acm.org/articles/bulletins/2020/march/dl-access-during-covid-19
Check them LISP papers.
They're not real threads but actors with message passing, I mean they're cheap.
Let's play a game about improving and confinement, currently the two hottest topics in SchemeBBS.
Every time you visit and see this thread in the front page, your duty is to read a paper of your choice and then post a link here. Rating, comments and abstracts of abstracts for bonus points. I'll start.
Oh and fellows chan archivers, sci-hub Russian hackers, torrent packers, in the name of Aaron Swartz, do your job.
https://dl.acm.org/doi/abs/10.1145/1529966.1529972
Common Lisp: the untold story, Kent M. Pitman
Nothing technical, just a mildly interesting historical account of the creation of the Common Lisp standard.
https://dl.acm.org/doi/abs/10.1145/3363562
A Survey of Compiler Testing, Junjie Chen et al.
A few years ago I was working on a frontend for a compiler and was wondering how testing is done for things like these, so I was very delighted to see this paper. It is an overview of the research done on testing compilers. They looked at the various parts of testing (testcase generation, test oracles, processing results, etc.), but I really missed a section that would discuss what were they testing for. Based on their summaries of the papers, it seems that there were at least one that tested the parsers only, multiple that tried to make the compiler crash, some that looked for missed optimizations and some that was just verifying semantics. Other than this small issue, the paper is well organized, the summaries are short and easy to understand, and it looks like they did a really throughout job. It seems to be the perfect paper to read if you are considering testing some compilers.
Which you should, as they couldn't find any work about testing Scheme or Lisp compilers!
>>2
Could we limit it to one paper per day? Otherwise I might get stuck in an infinite loop.
>>6
Yes, one per day is a reasonable limit.
Using Scheme to Control Simulated Modular Robots, Ulrik Pagh Schultz
keywords: cyberpunk, autism, https://anonradio.net/
This tutorial describes the current state of Scheme support in USSR... The ATRON is a homogeneous modular robot, meaning all modules in the robot are identical... Self-reconfiguration is the process of spatial transformation of the robot morphology from one shape to another... The simplest approach to supporting Scheme in the USSR simulator is to embed a JVM-compatible Scheme interpreter in the simulator. SISC is one such interpreter... Functional reactive programming is seen as a natural way to express the continuous computation performed in a robotic system, and was inspirational for the distributed information propagation done by our distributed fold function
>>8
Forgot the link: https://dl.acm.org/doi/abs/10.1145/2661103.2661114
https://dl.acm.org/doi/abs/10.1145/3341215.3358243
Bird Watch: A Fully Immersive VR Birdwatching Simulator, Marie A. Jarrel et al.
A virtual-reality game to practice identifying birds. At the moment limited only to ten species common to North America. I am somewhat sceptical of the transfer from virtual-reality to real-life, but they cite numerous research articles about it, some even suggesting that "dumbed down" or exaggerated visuals are not an issue. They are planning to test its effectiveness with a controlled study, I am looking forward to hear about their conclusions.
There's not much research being done about Scheme. Or maybe I am just bad at searching on this site?
>>11
I don't think there's much research on the Scheme language published in ACM. If you search author names you'll get a few results (Kent Dybvig, Oleg Kiselyov, Andy Wingo, ...)
>>10
This is cute, I feel like reading it. How did you find it? Are you into birdwatching?
https://dl.acm.org/doi/abs/10.1145/1529966.1529973
Scheme@33, by William D Clinger.
A look at the first 33 years of Scheme. I was unfamiliar with the original story so I was delighted to learn about how it was discovered. It shortly describes some of the research contributions that Scheme enabled, its strengths and its weakness. The part about standardization was interesting.
This is an ``extended abstract'', I hope it still counts.
>>12
Apparently Scheme was originally called Schemer but fall prey to the creat trap. I wonder if it was easier to search for it if it still had its original name.
>>13
A few years ago I noticed that I couldn't name most of the birds that I see, even some of the more common ones. This made me really embarrassed and I set out to correct it by learning to identify every single bird species native to my home. I started building an Anki pack but it wasn't a high priority and I am lazy, it is still not finished yet. Even worse: it is not very effective, I keep getting them wrong and it's kind of painful in general. With the lock-down I thought it was time to finally get over with it and learn about birds properly, connecting their appearances to a little more knowledge about them will surely help. I started reading and watching some documentaries, and when I saw the opportunity with ACM I searched for "ornithology".
I never did birdwatching before but now with the lock-down I do spend some time of my workday staring out of my window, I even started writing down the species I see. Does that count?
An One-Class Classification Approach to Detecting Porn Image, Yi Liu, Chuangbai Xiao, Zhe Wang, Chunxiao Bian
https://dl.acm.org/doi/pdf/10.1145/2425836.2425893
2 things:
- the keywords sound like weird fetish categories: SVM, BoW model, random forest...
- there's no porn sample shown in the study. The only remotely erotic picture is a woman wearing a bikini and it's been censored
https://dl.acm.org/doi/abs/10.1145/277631.277646
Visualizing the performance of higher-order programs, by
Oscar Waddell and J. Michael Ashley
Profiling Scheme code! Visualization means painting the source code in different shades according to time spent there. Two notable things. The first is, their solution lets you profile your program with different inputs, and the measurements can be compared using a custom function. They propose this to detect places of worse-than-linear time complexity. The other is, instead of recording the control-flow at runtime, they compute a control-flow graph at compile time, and later use it and the actual measurements to build a system of linear expressions, whose solution gives the intraprocedural profile data. This is sometimes under-constrained, which causes issues.
https://dl.acm.org/doi/10.1145/2776825
Cache efficient functional algorithms, by Guy E. Blelloch and Robert Harper
This is a short description of a cost-model and its language to analyse the cache efficiency of functional algorithms. It assumes that new values are allocated in sequential order and defines for them a nursery in the cache, while another part of the cache is designated as a read cache. The key idea seems to be compact data structures, which means that they can be read in linear cost (i.e., O(n/B), where B is the cache block size). I will probably read the longer article too as I am curious what are the practical takeaways.
https://dl.acm.org/doi/abs/10.5555/2392712.2392736
Blogging birds: generating narratives about reintroduced species to promote public engagement, by Advaith Siddharthan et al.
The goal here is to popularize red kite conservation efforts by blogging about the life of GPS tracked specimen. The second goal is to educate about their behaviour. To this end they first designed a study to verify that blogging about a birds private life makes the reader more sympathetic to their lot. They found out that indeed it does. After that they designed a prototype that would guess what the kite was up to based on their position. They plan to extend the model with various other things, like the proximity of other kites.
Do they also provide red kite meatloaf recipes?
>>20
probably
https://dl.acm.org/doi/10.1145/2815400.2815409
Coz: finding code that counts with causal profiling by Charlie Curtsinger and Emery D. Berger
This paper presents a novel way to profile multi-threaded programs. Conventional profilers measure how much time a program spends in its different parts. This is insufficient for multi-threaded programs, as optimizing these parts might not speed up overall performance at all. In some cases it might even slow it down, due to increased resource contention. To overcome this limitation, the authors introduce "virtual speedups": by slowing down everything else but the optimization target, one can estimate how much relative overall effect speeding up the target would cause.
They implemented a profiler based on this, available on Github: https://github.com/plasma-umass/coz It makes use of Linux's perf system. Instead of instrumenting the code, it collects samples and injects slowdowns every time the optimization target's address was found in the samples. Each thread processes their own samples, and the slowdowns are handled by a global and thread-local slowdown counts. Each time a thread find a sample containing the target, it increases both the global and its own thread-local count. If the local count is smaller than the global, it increases it and sleeps.
Their evaluation is promising, it has low overhead and the performance issues they found using it are interesting.
Springer also released a couple hundred books: https://hnarayanan.github.io/springer-books/
(posted in the wrong thread)
https://dl.acm.org/doi/pdf/10.1145/24697.24706
A critique of Abelson and Sussman or why calculating is better than scheming by Philip Wadler
This heretic paper advocates the use of Miranda (basically Haskell 0.1) instead of Scheme to teach novice students the principles of computer programming. The author has been using SICP in his class and his critics are pertinent and restraint (Abelson and Sussman even helped with an early draft of the paper). According to him, absence of pattern matching, static typing (and user-defined types), and lazy evaluation can be confusing for students. His examples are often pertinent although I was not convinced with the advantages of his implementation of a lambda calculus evaluator in Miranda and the only point he makes with the benefits of lazy evaluation concerns the Streams chapter (in which a modified interpreter with lazy evaluation is used anyway)
I think I've heard of this paper before. The conclusion is amusing. It's noted that an objection for the value of Miranda in an entry level course is that Miranda has no use in the real world. You then understand that "real world" at the time of writing means Cobol and Fortran, as opposed to the esoteric Lisp, Miranda and Pascal. Python is now the language used for teaching 6.001 and that debate is closed.
>>24
It seems to me teaching abstraction is more important than the convenience of pattern matching, and the feature trade off here was not in Miranda's favor. I do agree with their comments about data types and ADTs over all though, I don't recall it being mentioned but I also agree with the virtues of strong static inferred typing so long as sufficient generic primitives are provided. They seem to have to some extent missed the point of having different models of computation. The point is not to approach some easy to understand view of computation but to approach powerful ways of viewing the system at hand. On lazy evaluation, it does remove special forms but this isn't without cost, reasoning about certain algorithms, especially algorithms using mutation, can be dramatically more difficult. Delayed evaluation is a useful tool for simplifying certain procedures.
Speaking of computer science education...
https://dl.acm.org/doi/abs/10.1145/2999541.2999554
Replication in computing education research: researcher attitudes and experiences by Ahadi et al.
We have published results that we didn't believe ourselves, so we tried to replicate them.
This was one of the better answers to a survey the authors of this paper conducted to find out what's the deal with the abysmal replication rate in their field. First, the good: most researchers who answered this survey believe replication to be a good thing. However, their views on how much of the studies done in CS education could even be replicated was tragic, with the median being at just 30%, and the maximum at 70%. This maximum is lower than the average in some other fields... While ideologically supporting replication, many of those who answered are unwilling to do the actual work, as they either prefer working on novel problems or realize that not even the journals care about reproductions and will likely refuse to publish their work. I guess the takeaways is: next time you are reading about computer science education, remember that not even the researchers active in this field have any trust in the veracity of the published papers.
Maybe things have improved since 2016?
>>26
This is a pretty common problem, especially in social sciences like education: https://en.wikipedia.org/wiki/Replication_crisis
Maybe things have improved since 2016?
https://dl.acm.org/doi/10.1145/3345328
A Systematic Investigation of Replications in Computing Education Research by Hao et al.
According to this study, between 2009 and 2018, only 2.38% of the papers published in the top three conferences and top two journals on CS education were replications of previous studies. Which is better than for education in general (just 0.13%), but still pretty bad.
Replications have a hard time getting published, unless it's a surprising result.
Here's an aggregation of scheme related academic articles I stumbled across today: https://github.com/schemedoc/bibliography
>>30
BibTeX files would be nice.
>>31
That would be nice.
It is over today. Grab what you still can.
>>30
Thanks for sharing that.