Dave Eckhardt

You may already be aware of the following distinction, but as your site definitely takes the systems interpretation of "computer science" (completely in keeping with your institution's own focus: https://cs.pku.edu.cn/English/About_Us/Overview.htm ), it may be helpful to recall that, in other departments, "computer science" may denote theory instead. Lagniappe: https://www.cs.purdue.edu/homes/dec/essay.criticize.html

Telcos actually realized that dream in cellular networks. Tons of scams followed with random webservers automagically charging your wireless plan for "services" https://www.cs.purdue.edu/homes/chunyi/pubs/ccs12-peng.pdf

This was and still is the best guidance[1] I ever indirectly received in uni. I hope it continues to help others. [1] https://www.cs.purdue.edu/homes/dec/essay.phd.html

I'm doing a rewrite[0] of OctoSQL[1], partly to make it push-based instead of pull-based, and for now it's been much simpler to work with, won't get into the detailed reasoning in this comment. However, if somebody is interested, this is a great paper on how to architect a query compiler: https://www.cs.purdue.edu/homes/rompf/papers/tahboub-sigmod18.pdf I found it very enlightening and simple to implement. The paper also delves into details why the push-based architecture has more room for optimizations. [0]:https://github.com/cube2222/octosql/tree/redesign [1]:https://github.com/cube2222/octosql/

Reminded me of the following paper, Using Coq to Write Fast and Correct Haskell. https://www.cs.purdue.edu/homes/bendy/Fiat/FiatByteString.html

There’ve been some follow-up papers to Appel’s Compiling with Continuations over the years. The most recent one, Compiling with Contiuations, or Without? Whatever. [1] is pretty interesting — they show a direct-style functional IR with 2nd-class continuations, and describe how it can be used for both traditional SSA-style optimizations, as well as some optimizations that more naturally operate on CPS-style IR. [1]: https://www.cs.purdue.edu/homes/rompf/papers/cong-preprint201811.pdf

Hi all, Author here, great to see our paper on the front page today. Happy to answer any questions! Since Spark was already mentioned in the comments, you might be interesting in the parallel/follow-on work we did applying similar techniques to accelerate Spark: "Flare: Optimizing Apache Spark for Scale-Up Architectures and Medium-Size Data" (to appear at OSDI, preprint here: https://www.cs.purdue.edu/homes/rompf/papers/essertel-osdi18.pdf) If you're running Spark in production and are interested in trying it out, please leave your contact data here: https://flaredata.github.io. We're a small team and have a long waitlist, but should have some open slots in our private beta program this Fall. Cheers, - Tiark

If you are turning to PHP for string manipulation, then you are going to love the Practical Extraction and Reporting Language: https://www.cs.purdue.edu/homes/cs290w/perlLecs/PerlPatterns.html

The point is that while both reference counting and garbage collection are types of automatic memory management, the reverse isn't true. From a 1976 paper on automatic memory management https://www.cs.purdue.edu/homes/hosking/690M/deutsch.pdf "Automatic reclamation of storage no longer in use is done by the following two techniques: * Garbage collection * Reference counting" Note that these are two separate items and that one is not a subset of the other (and vice versa). It is simply incorrect to call reference counting "garbage collection" when the academic and industrial practices already have explicit meanings to these two terms.

That's a great idea. I had another approach that assumed the entry addresses were aligned to 32/64 bit words in memory as structure's by default are. Then the next pointers will never have the ones or twos bit place set and can be used as a visited marker[1]. This gives a O(n) with a much smaller constant factor than the hair and tortoise. 1.https://www.cs.purdue.edu/homes/cs240/lectures/Lecture-7.pdf

I'm not sure anyone knows the answer to that question. My best first approximation is to just jump into an open-source project and try to fix bugs. It gets you to both read code by those who are (presumably) more experienced, while also working your problem-solving skills. Classical CS education is also important; I went to a school with a fairly math-heavy CS program so that's how I learned it. Our algorithms text was pretty good, but it's on my shelf at home, so I can't recommend it by name. The lecture notes for CS 182 are reasonably good for the really basic stuff: http://www.cs.purdue.edu/homes/raof/cs182-f12/schedule.shtml [edit] Not quite as complete as they used to be; it was previously all taught from lecture notes, but they now have 2 textbooks they use as well

I just read one of the papers that is a part of this project, "An Analysis of the Dynamic Behavior of JavaScript Programs" (http://sss.cs.purdue.edu/projects/dynjs/pldi275-richards.pdf), and I thought it was an excellent study of how JavaScript is used in the wild. They also have a more recent paper that goes into uses of eval in depth which I have yet to read (http://www.cs.purdue.edu/homes/jv/pubs/ecoop11.pdf). Also, it's worth noting that the authors have the code and data available from for their experiments.

Check out the Delta Debugging paper. There has been a ton of follow-on work (1000+ direct citations), and lots of tools exist. Here's the citation, abstract and link to a PDF copy: Simplifying and isolating failure-inducing input Andreas Zeller, Ralf Hildebrandt IEEE Transactions on Software Engineering 28 (2), 183-200, 2002 Given some test case, a program fails. Which circumstances of the test case are responsible for the particular failure? The delta debugging algorithm generalizes and simplifies the failing test case to a minimal test case that still produces the failure. It also isolates the difference between a passing and a failing test case. In a case study, the Mozilla Web browser crashed after 95 user actions. Our prototype implementation automatically simplified the input to three relevant user actions. Likewise, it simplified 896 lines of HTML to the single line that caused the failure. The case study required 139 automated test runs or 35 minutes on a 500 MHz PC. http://cs.purdue.edu/homes/xyzhang/fall07/Papers/delta-debugging.pdf Edit: adjusted tone

Very, very excited about Scala 3. Here are some of the things I'm looking forward to using: * Generally a more clean language for everyday use, codifying existing patterns like newtypes (opaque types), typeclass derivation and extension methods * Improved type inference & lots of other quality of life improvements * A macro system based on the idea of multi-stage programming. This has a lot of potential for improving both type-safety and performance. An example: beating existing database systems query optimization with ~500 lines of Scala code [1] * TASTY, a new intermediate representation (AST) for artifacts. This means that Scala will have a much better version upgrade / binary compatibility story in the future. (e.g. TASTY is used for facilitating 2.13 <-> 3.0 bi-direction upgrade!) * Significant compile time improvements over Scala2 alraedy[2] (and we're only at M1 release)! Scala has already been a wonderful language to work with professionally with many great tooling (linting, automatic migration, 2 good OSS IDEs), and I think Scala 3 will certainly push the state-of-the-art forward in many departments in the coming years. [1]:https://www.cs.purdue.edu/homes/rompf/papers/rompf-icfp15.pdf [2]: https://twitter.com/not_xuwei_k/status/1323643312230772737

As for JavaScript, Google Closure Compiler does some dead code elimination (DCE, a.k.a. tree shaking in Lisp lingo) as an optimization but it unfortunately doesn't tell you which parts of the code is dead. It also does not to DCE alone but does some aggressive size optimizations with it so, again unfortunately, it cannot output otherwise-identical code with only DCE applied. This part is more of a shameless plug, but I believe public/industry/developers should be aware of what tools & techniques academia develops so that the researcher's efforts can be more useful. There are some static analyzers for JavaScript such as JSAI, SAFE, and TAJS (disclaimer: I'm working on a project related to JSAI on the lab which developed it). These static analyzers can discover the dead code if given all the entry points however: - They don't have facilities to report the dead-code AFAIK (this is a trivial thing to add _in theory_, if there are parts of the program _unvisited_ by any of these, that part of the program is guaranteed to be dead). If somebody wants to add such a facility to any of the tools they are welcome. In case of JSAI, I'm willing to provide them all the information I can. - They are conservative (e.g. sound) tools and may find too few dead code results. - They don't play well with `eval` & friends in general although they try their best[0], the web frameworks rely on eval-like highly-dynamic approaches a lot to be generic enough and that hurts precision of such…

I think the major problem in CAD/CAM software is the creation of technical drawings. I enjoy every new CAD program (solvespace, implicitCAD, nanoCAD, ...) when they come but each time it lacks this vital function. Even fat dinausors like CATIA, Pro/E, Inventor & co have a very poor ux at that level. So I will recommend to master the rules of technical drawings and geometric dimensionning and tolerancing before going to deep in 3D. Likewise, BRep, CSG, constraints solvers, code/GUI will be just straightforward "plugins". It's safer and more useable in real life. By the way, the Purdue University have some good innovative lectures, ie. Erep [1] Computer Aided Engineering Design by Anupam Saxena & Birendra Sahay is cool and informative. In general, the Indian Institute of Technology of Kampur [2] has some pretty intense books on the subject. Finally, Knowledge-based engineering [127] will extend a lot your future awesome opensource haskell CAD package! [1] https://www.cs.purdue.edu/homes/cmh/distribution/papers/Erep/ [2] http://www.iitk.ac.in/cad/ [127] https://en.wikipedia.org/wiki/Knowledge-based_engineering

It will be hard to come up with an accessible general framework to express general problem situations without resorting to either (a) an explosion of templates for solving the N-most-common kinds of problems (the browsing through which will be worse than learning the math and the programming); (b) a set of elaborate but limiting special-purpose programs (much like iPhone apps that might help, for example, a metal welder to choose stock feed rate, gas mix/flow, and electric current depending on metal type and thickness to be joined; or mortgage calculators). Worse yet, it doesn't take much for interesting problems to get into the land of over- or under-constraint. In an under-constrained problem there are a multitude of solutions forming their own K-dimensional space, and then one likely should apply some secondary optimization criteria to determine the best solution. In over-constrained problems there is no exact solution, but again one needs to impose some optimization to get something "close enough" to the desired criteria, according to some norm. Explaining the need for optimization, letting the user explore the solution space, and having them express these optimization criteria will be tough. A Google search for "geometric constraint solver" leads to this paper: http://www.cs.purdue.edu/homes/cmh/distribution/papers/Constraints/CAD… -- what appears to be a lot of work just in helping people/machines solve geometric problems (though surely more widely…

Modula-3 has it despite not having a continue statement: https://www.cs.purdue.edu/homes/hosking/m3/reference/exit.html But there, it's more comprensible because in order to define the interaction of return (and exit) with exceptions, they define return, and exit, to be exceptions. So then it's more obvious why return can be "caught".

I haven't read any of the code to see how it compares, but this work reminds me of research from Nada Amin & Tiark Rompf on "towers of interpreters", where a stack of meta-circular interpreters uses some explicit staging operations that make it possible to specialize for the interpreter code in a way that removes overhead. https://www.cs.purdue.edu/homes/rompf/papers/amin-popl18.pdf

> We observe that they essentially solve the same problem, i.e., how to store a collection of sorted integers with as few as possible bits and support query processing as fast as possible. Due to historical reasons, bitmap compression and inverted list compression were developed as two separated lines of research in the database area and information retrieval area. https://www.cs.purdue.edu/homes/csjgwang/pubs/SIGMOD17-Bitmap.pdf Presentation slides https://pdfs.semanticscholar.org/32bc/322fce0cf6c99b0dd31f1aa2e2715253… Mentioned in https://github.com/junchangwang/reading-list/blob/main/Database/Bitmap… see also https://roaringbitmap.org/publications/ If you like this, you might like the work of https://en.wikipedia.org/wiki/Gonzalo_Navarro The lead author has a great body of research https://www.cs.purdue.edu/homes/csjgwang/pubs/

Operating System Design Volume 2: Internetworking with XINU, 1987. ISBN 0-13-637414-X 025 Shows how to add IP/UDP to a simple Unix-like OS. You might want to also read volume 1: Operating System Design - The XINU Approach, Second Edition, 2015. ISBN 9781498712439 https://www.cs.purdue.edu/homes/comer/osbooks.html

If you're designing a language you might be interested in this paper. https://www.cs.purdue.edu/homes/rompf/papers/xhebraj-ecoop22.pdf > We design a type system that tracks the underlying storage mode of values, and when a function returns a stack-allocated value, we just don’t pop the stack Instead, the stack frame is de-allocated together with a parent the next time a heap-allocated value or primitive is returned. > Our evaluation shows that this execution model reduces heap and GC pressure and recovers spatial locality of programs improving execution time between 10% and 25% with respect to standard execution.

Circa 1990 we seriously considered doing Newton OS in Modula-3 [0], which had all the things…modules, generics, exceptions, GC, etc. But we ended up taking a chance on C++ (in the form of CFront). Modula-3 was very cool, though. [0] https://www.cs.purdue.edu/homes/hosking/m3/reference/intro.html

I didn't know about his inequalities, but I found (1) that provides an example of using Talagrand inequality applied to the longest increasing subsequence problem (12 pages, easy to read). It seems to be a broad generalization of the Hamming distance. (1) https://www.cs.purdue.edu/homes/hmaji/teaching/Spring%202018/lectures/…

I read this paper claiming that there's no fundamental limitations to Postgres' vector support down the line. Pretty excited for the work Supabase, Neon, Tembo, ourselves at ParadeDB and many others are doing to keep pushing it forward. Definitely more and more vector production workloads coming to Postgres Paper: https://www.cs.purdue.edu/homes/csjgwang/pubs/ICDE24_VecDB.pdf

Sounds a bit like jockey applied to qemu. Very neat indeed. https://www.cs.purdue.edu/homes/xyzhang/spring07/Papers/HPL-2005-46.pd…

The delta debugging paper[1] pointed out that the bug (change set) must satisfy certain properties (Definition 6-8) for the divide and conquer technique to work. [1] Yesterday, my program worked. Today, it does not. Why? PDF link: https://www.cs.purdue.edu/homes/xyzhang/spring07/Papers/p253-zeller.pd…

I went to Purdue. Its LUG had 10 year birthday party of Debian, and alumnus Ian Murdock was there. Sadly, it was a week before the semester started, so I wasn't in-town, yet. https://www.cs.purdue.edu/news/articles/2003/debian-birthday-celebrati…

Forking can be quite slow (milliseconds), though there are techniques to speed it up: https://www.cs.purdue.edu/homes/pfonseca/papers/eurosys21-odf.pdf I believe wasmtime can be faster as it doesn’t need to create as many new OS resources and just resets some memory maps. Only really meaningful for simple request handlers taking a few milliseconds.

Some of the links, funnily, are based on "real" links: https://www.cs.cmu.edu/~fp/courses/lp/lectures.html is broken but https://www.cs.cmu.edu/~fp/courses/lp/ is the page for a Logic Programming course. https://www.cs.purdue.edu/homes/hosking/726/html/prolog_lists.html is broken, but there are many pages in the format https://www.cs.purdue.edu/homes/hosking/XXX corresponding to courses taught by that guy, but 726 is nonexistent.