Ramanujan's total known/preserved output today is 37 published papers and these four notebooks; all of it is available on the site. The notebooks have been transcribed and published in several volumes with explanation (as mentioned above); those are the only thing not included on this site (and arguably, not "by" Ramanujan).
Checking for my own “benchmark”, a gameboy emulator in several different languages[0]; it’s CPU-bound but across ~3k lines of code, so slightly more representative of real-world apps than a single-function tight-loop microbenchmark:
zig: Emulated 600 frames in 0.24s (2521fps)
rs: Emulated 600 frames in 0.37s (1626fps)
cpp: Emulated 600 frames in 0.40s (1508fps)
nim: Emulated 600 frames in 0.44s (1367fps)
go: Emulated 600 frames in 1.75s (342fps)
php: Emulated 600 frames in 23.74s (25fps)
py: Emulated 600 frames in 26.16s (23fps) # PyPy
py: Emulated 600 frames in 33.10s (18fps) # 3.11
py: Emulated 600 frames in 61.43s (9fps) # 3.10
Doubling the speed is pretty nice :D Still the slowest out of all implementations though :P
It'll teach you enough to be dangerous. Obviously your learning has just begun, but with a mental platform that lets you study other resources in time and practically test things out.
- SBCL’s built-in static executable compiler for deployment, or sometimes docker if that happens to be more convenient
- Practical Common Lisp for training; Paradigms in AI Programming for taking a trained Lisp programmer “minting” a better Lisp programmer
For individual libraries, there are too many to name. I like yason for JSON, Hunchentoot for web servers, Postmodern for Postgres/SQL, cl-sqlite for SQLite, fiasco for testing, etc.
I'm not going opine on the list of removed features, but if the author is interested in a browser that's easy to understand, written in a memory-safe language, and (heh) eschews performance in favor of simplicity...
It implements a (very simple) web browser in about 1000 lines of Python, and it's pretty easy to extend with new features (many of which are exercises in the book). I'm working on the seventh chapter right now---it adds tabs.
There's not much about firewalls etc. there IIRC, more about low level concepts like DNS, TCP and so on. Anyway it's a great book. You can also read online at https://hpbn.co
hwayne's Learn TLA+ [0] is a very approachable introduction and survey. Lamport's TLA+ course [1] is an excellent follow on after going through Hillel's course. That link also includes the book itself.
1. whenever you see strncpy(), there's a bug in the code. Nobody remembers if the `n` includes the terminating 0 or nor. I implemented it, and I never remember. I always have to look it up. Don't trust your memory on it. Same goes for all the `n` string functions.
2. be aware of all the C string functions that do strlen. Only do strlen once. Then use memcmp, memcpy, memchr.
3. assign strlen result to a const variable.
4. for performance, use a temporary array on the stack rather than malloc. Have it fail over to malloc if it isn't long enough. You'd be amazed how this speeds things up. Use a shorter array length for debug builds, so your tests are sure to trip the fail over.
5. remove all hard-coded string length maximums
6. make sure size_t is used for all string lengths
7. disassemble the string handling code you're proud of after it compiles. You'll learn a lot about how to write better string code that way
8. I've found subtle errors in online documentation of the string functions. Never use them. Use the C Standard. Especially for the `n` string functions.
9. If you're doing 32 bit code and dealing with user input, be wary of length overflows.
10. check again to ensure your created string is 0 terminated
11. check again to ensure adding the terminating 0 does not overflow the buffer
12. don't forget to check for a NULL pointer
13. ensure all variables are initialized before using them
14. minimize the lifetime of each variable
15. do not recycle variables - give each temporary its own name. Try to make these temporaries const, refactor if that'll enable it to be const.
16. watch out for `char` being either signed or unsigned
17. I structure loops so the condition is <. Avoid using <=, as odds are high that'll will result in a fencepost error
That's all off the top of my head. Hope it's useful for you!
- [JuliaLang.org](https://julialang.org/), the home site with the downloads to get started, and links to learning resources.
- [JuliaHub](https://juliahub.com/ui/Home) indexes open-source Julia packages and makes the entire ecosystem and documentation searchable from one place.
- [JuliaAcademy](https://juliaacademy.com/courses), which has free short courses in Data Science, Introduction to Julia, DataFrames.jl, Machine Learning, and more.
It's an important development. Forensic labs and companies are expert witnesses with black box processes and the incentive to protect the authority of their profession. They are as likely to lie as any other witness. Perhaps even moreso.
"Those arguing on behalf of the defense cited past problems with other genetic testing software such as STRmix and FST (Forensic Statistical Tool). Defense expert witnesses Mats Heimdahl and Jeanna Matthews, for example, said that STRmix had 13 coding errors that affected 60 criminal cases, errors not revealed until a source code review." "They also pointed out, as the appeals court ruling describes, how an FST source code review "uncovered that a 'secret function . . . was present in the software, tending to overestimate the likelihood of guilt.'"
Maybe there's just something about Toronto and compromised processes, but defense challenges to the integrity of automated systems looks like a growth field.
I teach a graduate course in optimization methods for machine learning and engineering [1,2]. Julia is just perfect for teaching numerical algorithms.
First, it removes the typical numpy syntax boilerplate. Due to its conciseness, Julia has mostly replaced showing pseudo-code on my slides. It can be just as concise / readable; and on top the students immeditaly get the "real thing" they can plug into Jupyter notebooks for the exercises.
Second, you get C-like speed. And that counts for numerical algorithms.
Third, the type system and method dispatch of Julia is very powerful for scientific programming. It allows for composition of ideas in ways I couldn't imagine before seeing it in action. For example, in the optimization course, we develop a mimimalistic implementation of Automatic Differentiation on a single slide. And that can be applied to virtually all Julia functions and combined with code from preexisting Julia libraries.
When our daughter was born with a rare life threatening condition my wife used SciHub to read articles about her condition. While the doctors had merely skimmed the pages, my wife pored over them and found a suggestion of using a particular drug. After asking five different doctors about it, one finally agreed to prescribe it. It was strange how reticent doctors were to prescribe something and instead just told us she was going to die. If she’s believed to be terminal anyway, why not prescribe a relatively well known drug and see if it helps?
I’m happy to say our daughters prognosis has improved greatly since she started this treatment. Without SciHub she might not still be with us.
